Added temperature units.

Added TemperatureAttribute.
Added temperature units and modified UnitAttribute to use linear function instead of ratio.
Added TemperatureTests.cs.
Added invariant unit abbreviations for temperature units. Still missing russian. Failing test.

Author: angularsen

Src/UnitsNet/Attributes/Attributes.cs

@@ -29,7 +29,7 @@ public class AngleAttribute : UnitAttribute
         public override Unit BaseUnit { get { return Unit.Degree; } }
 
         public override string XmlDocSummary { get { return "In geometry, an angle is the figure formed by two rays, called the sides of the angle, sharing a common endpoint, called the vertex of the angle."; } } 
-        public AngleAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public AngleAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -39,7 +39,7 @@ public class AreaAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.SquareMeter; } }
         public override string XmlDocSummary { get { return "Area is a quantity that expresses the extent of a two-dimensional surface or shape, or planar lamina, in the plane. Area can be understood as the amount of material with a given thickness that would be necessary to fashion a model of the shape, or the amount of paint necessary to cover the surface with a single coat.[1] It is the two-dimensional analog of the length of a curve (a one-dimensional concept) or the volume of a solid (a three-dimensional concept)."; } }
-        public AreaAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public AreaAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -49,7 +49,7 @@ public class ElectricPotentialAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.Volt; } }
         public override string XmlDocSummary { get { return "In classical electromagnetism, the electric potential (a scalar quantity denoted by Φ, ΦE or V and also called the electric field potential or the electrostatic potential) at a point is the amount of electric potential energy that a unitary point charge would have when located at that point."; } }
-        public ElectricPotentialAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public ElectricPotentialAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -59,7 +59,7 @@ public class FlowAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.CubicMeterPerSecond; } }
         public override string XmlDocSummary { get { return "In physics and engineering, in particular fluid dynamics and hydrometry, the volumetric flow rate, (also known as volume flow rate, rate of fluid flow or volume velocity) is the volume of fluid which passes through a given surface per unit time. The SI unit is m3·s−1 (cubic meters per second). In US Customary Units and British Imperial Units, volumetric flow rate is often expressed as ft3/s (cubic feet per second). It is usually represented by the symbol Q."; } }
-        public FlowAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public FlowAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -69,7 +69,7 @@ public class ForceAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.Newton; } }
         public override string XmlDocSummary { get { return "In physics, a force is any influence that causes an object to undergo a certain change, either concerning its movement, direction, or geometrical construction. In other words, a force can cause an object with mass to change its velocity (which includes to begin moving from a state of rest), i.e., to accelerate, or a flexible object to deform, or both. Force can also be described by intuitive concepts such as a push or a pull. A force has both magnitude and direction, making it a vector quantity. It is measured in the SI unit of newtons and represented by the symbol F."; } }
-        public ForceAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public ForceAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -79,7 +79,7 @@ public class LengthAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.Meter; } }
         public override string XmlDocSummary { get { return "Many different units of length have been used around the world. The main units in modern use are U.S. customary units in the United States and the Metric system elsewhere. British Imperial units are still used for some purposes in the United Kingdom and some other countries. The metric system is sub-divided into SI and non-SI units."; } }
-        public LengthAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public LengthAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -89,7 +89,7 @@ public class MassAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.Kilogram; } }
         public override string XmlDocSummary { get { return "In physics, mass (from Greek μᾶζα \"barley cake, lump [of dough]\") is a property of a physical system or body, giving rise to the phenomena of the body's resistance to being accelerated by a force and the strength of its mutual gravitational attraction with other bodies. Instruments such as mass balances or scales use those phenomena to measure mass. The SI unit of mass is the kilogram (kg)."; } }
-        public MassAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public MassAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -99,7 +99,7 @@ public class PressureAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.Pascal; } }
         public override string XmlDocSummary { get { return "Pressure (symbol: P or p) is the ratio of force to the area over which that force is distributed. Pressure is force per unit area applied in a direction perpendicular to the surface of an object. Gauge pressure (also spelled gage pressure)[a] is the pressure relative to the local atmospheric or ambient pressure. Pressure is measured in any unit of force divided by any unit of area. The SI unit of pressure is the newton per square metre, which is called the pascal (Pa) after the seventeenth-century philosopher and scientist Blaise Pascal. A pressure of 1 Pa is small; it approximately equals the pressure exerted by a dollar bill resting flat on a table. Everyday pressures are often stated in kilopascals (1 kPa = 1000 Pa)."; } }
-        public PressureAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public PressureAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -109,8 +109,28 @@ public class RotationalSpeedAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.RevolutionPerSecond; } }
         public override string XmlDocSummary { get { return "Rotational speed (sometimes called speed of revolution) is the number of complete rotations, revolutions, cycles, or turns per time unit. Rotational speed is a cyclic frequency, measured in radians per second or in hertz in the SI System by scientists, or in revolutions per minute (rpm or min-1) or revolutions per second in everyday life. The symbol for rotational speed is ω (the Greek lowercase letter \"omega\")."; } }
-        public RotationalSpeedAttribute(double ratio, string pluralName = (string)null)
-            : base(pluralName, ratio)
+        public RotationalSpeedAttribute(double slope, string pluralName = (string)null)
+            : base(pluralName, slope, offset: 0)
+        {
+        }
+    }
+
+    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
+    public class TemperatureAttribute : UnitAttribute
+    {
+        public override Unit BaseUnit { get { return Unit.Kelvin; } }
+        public override string XmlDocSummary { get { return "A temperature is a numerical measure of hot or cold. Its measurement is by detection of heat radiation or particle velocity or kinetic energy, or by the bulk behavior of a thermometric material. It may be calibrated in any of various temperature scales, Celsius, Fahrenheit, Kelvin, etc. The fundamental physical definition of temperature is provided by thermodynamics."; } }
+
+        /// <summary>
+        /// Define a temperature unit by a linear mapping function to the base unit Kelvin.
+        /// Example: Celsius is defined as C = K - 273.15. To define this as a function to the base unit,
+        /// we invert it and get K = C + 273.15. From the function y = ax + b
+        /// we find the slope 'a' as 1 and 'b' as 273.15.
+        /// </summary>
+        /// <param name="slope">Slope 'a' of function y = ax + b.</param>
+        /// <param name="offset">Y-intercept 'b' of function y = ax + b.</param>
+        /// <param name="pluralName">Name of unit in plural form. Used in methods and properties of unit class, such as FromMeters() method and Meters property in Length class.</param>
+        public TemperatureAttribute(double slope, double offset = 0, string pluralName = (string)null) : base(pluralName, slope, offset)
         {
         }
     }
@@ -120,7 +140,7 @@ public class TorqueAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.Newtonmeter; } }
         public override string XmlDocSummary { get { return "Torque, moment or moment of force (see the terminology below), is the tendency of a force to rotate an object about an axis,[1] fulcrum, or pivot. Just as a force is a push or a pull, a torque can be thought of as a twist to an object. Mathematically, torque is defined as the cross product of the lever-arm distance and force, which tends to produce rotation. Loosely speaking, torque is a measure of the turning force on an object such as a bolt or a flywheel. For example, pushing or pulling the handle of a wrench connected to a nut or bolt produces a torque (turning force) that loosens or tightens the nut or bolt."; } }
-        public TorqueAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public TorqueAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }
@@ -130,7 +150,7 @@ public class VolumeAttribute : UnitAttribute
     {
         public override Unit BaseUnit { get { return Unit.CubicMeter; } }
         public override string XmlDocSummary { get { return "Volume is the quantity of three-dimensional space enclosed by some closed boundary, for example, the space that a substance (solid, liquid, gas, or plasma) or shape occupies or contains.[1] Volume is often quantified numerically using the SI derived unit, the cubic metre. The volume of a container is generally understood to be the capacity of the container, i. e. the amount of fluid (gas or liquid) that the container could hold, rather than the amount of space the container itself displaces."; } }
-        public VolumeAttribute(double ratio, string pluralName = (string)null) : base(pluralName, ratio)
+        public VolumeAttribute(double slope, string pluralName = (string)null) : base(pluralName, slope, offset: 0)
         {
         }
     }

Src/UnitsNet/Attributes/UnitAttribute.cs

@@ -2,6 +2,32 @@
 
 namespace UnitsNet.Attributes
 {
+    public struct LinearFunction
+    {
+        /// <summary>
+        /// Slope of function, a, in y(x) = ax + b.
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        public readonly double a;
+
+        /// <summary>
+        /// Y-intercept of function, b, in y(x) = ax + b.
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        public readonly double b;
+
+        /// <summary>
+        /// Create linear function by its slope and y-intercept constants.
+        /// </summary>
+        /// <param name="a">Slope of function, a, in y(x) = ax + b.</param>
+        /// <param name="b">Y-intercept of function, b, in y(x) = ax + b.</param>
+        public LinearFunction(double a, double b)
+        {
+            this.b = b;
+            this.a = a;
+        }
+    }
+
     [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
     public abstract class UnitAttribute : Attribute
     {
@@ -21,16 +47,25 @@ public abstract class UnitAttribute : Attribute
         ///     Ratio of unit to base unit. For example, <see cref="Unit.Kilometer" /> is 1000:1 of the base unit
         ///     <see cref="Unit.Meter" />.
         /// </summary>
-        public readonly double Ratio;
+        public readonly LinearFunction LinearMappingFromBaseUnit;
 
         /// <summary>
         ///     XML doc summary for unit class. Will be inserted when generating the class from T4 template.
         /// </summary>
         public abstract string XmlDocSummary { get; }
 
-        public UnitAttribute(string pluralName, double ratio)
+        public UnitAttribute(string pluralName, double slope, double offset)
         {
-            Ratio = ratio;
+            // Example: Kilometer has slope 1000, meaning for every kilometer the base unit increases with 1000 meters.
+            // a: 1000
+            // b: 0
+            // y: base unit value in meters
+            // x: unit value in kilometers
+            // new Length(2000).Kilometers => (y - b) / a = (2000 - 0) / 1000 = 2km
+            // Length.FromKilometers(2) => y = ax + b = 1000*2 + 0 = 2000m
+            double a = slope;
+            double b = offset;
+            LinearMappingFromBaseUnit = new LinearFunction(a, b);
             PluralName = pluralName;
         }
     }

Src/UnitsNet/Generated Code/AngleUnit.g.cs

@@ -41,14 +41,22 @@ public Angle(double degrees) : this()
 
         #region Unit Properties
 
+        /// <summary>
+        /// Get Angle in Gradians.
+        /// </summary>
+        /// <remarks>Example: x = (y - b) / a where x is value in Gradians and y is value in base unit Degrees.</remarks>
         public double Gradians
         {
-            get { return Degrees/0.9; }
+            get { return (Degrees - (0)) / 0.9; }
         }
 
+        /// <summary>
+        /// Get Angle in Radians.
+        /// </summary>
+        /// <remarks>Example: x = (y - b) / a where x is value in Radians and y is value in base unit Degrees.</remarks>
         public double Radians
         {
-            get { return Degrees/57.2957795130823; }
+            get { return (Degrees - (0)) / 57.2957795130823; }
         }
 
         #endregion
@@ -60,19 +68,31 @@ public static Angle Zero
             get { return new Angle(); }
         }
 
+        /// <summary>
+        /// Get Angle from Degrees.
+        /// </summary>
+        /// <remarks>Example: y = ax + b where x is value in Degrees and y is value in base unit Degrees.</remarks>
         public static Angle FromDegrees(double degrees)
         {
-            return new Angle(degrees*1);
+            return new Angle(1 * degrees + 0);
         }
 
+        /// <summary>
+        /// Get Angle from Gradians.
+        /// </summary>
+        /// <remarks>Example: y = ax + b where x is value in Gradians and y is value in base unit Degrees.</remarks>
         public static Angle FromGradians(double gradians)
         {
-            return new Angle(gradians*0.9);
+            return new Angle(0.9 * gradians + 0);
         }
 
+        /// <summary>
+        /// Get Angle from Radians.
+        /// </summary>
+        /// <remarks>Example: y = ax + b where x is value in Radians and y is value in base unit Degrees.</remarks>
         public static Angle FromRadians(double radians)
         {
-            return new Angle(radians*57.2957795130823);
+            return new Angle(57.2957795130823 * radians + 0);
         }
 
         #endregion