Flow, revolution, Pressure, Localization, Unittests

Src/UnitsNet/Flow.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Globalization;
+
+namespace UnitsNet
+{
+	/// <summary>
+	///     A class for representing flow.
+	/// </summary>
+	public struct Flow : IComparable, IComparable<Flow>
+	{
+		private const double SecondToMinuteRatio = 60;
+		private const double SecondToHourRatio = 3600;
+
+		public readonly double CubicMeterPerSecond;
+
+		private Flow(double cubicMeterPerSecond)
+			: this()
+		{
+			CubicMeterPerSecond = cubicMeterPerSecond;
+		}
+
+		public double CubicMeterPerHour
+		{
+			get { return CubicMeterPerSecond / SecondToHourRatio; }
+		}
+
+		#region Static
+
+		public static Flow Zero
+		{
+			get { return new Flow(); }
+		}
+
+		public static Flow FromCubicMeterPerHour(double cmh)
+		{
+			return new Flow(cmh * SecondToHourRatio);
+		}
+
+		public static Flow FromCubicMeterPerSecond(double cms)
+		{
+			return new Flow(cms);
+		}
+
+		#endregion
+
+		#region Equality / IComparable
+
+		public int CompareTo(object obj)
+		{
+			if (obj == null) throw new ArgumentNullException("obj");
+			if (!(obj is Flow)) throw new ArgumentException("Expected type Flow.", "obj");
+			return CompareTo((Flow)obj);
+		}
+
+		public int CompareTo(Flow other)
+		{
+			return CubicMeterPerSecond.CompareTo(other.CubicMeterPerSecond);
+		}
+
+		public static bool operator <=(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond <= right.CubicMeterPerSecond;
+		}
+
+		public static bool operator >=(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond >= right.CubicMeterPerSecond;
+		}
+
+		public static bool operator <(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond < right.CubicMeterPerSecond;
+		}
+
+		public static bool operator >(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond > right.CubicMeterPerSecond;
+		}
+
+		public static bool operator ==(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond == right.CubicMeterPerSecond;
+		}
+
+		public static bool operator !=(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond != right.CubicMeterPerSecond;
+		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null || GetType() != obj.GetType())
+			{
+				return false;
+			}
+
+			return CubicMeterPerSecond.Equals(((Flow)obj).CubicMeterPerSecond);
+		}
+
+		public override int GetHashCode()
+		{
+			return CubicMeterPerSecond.GetHashCode();
+		}
+		#endregion
+
+		#region Arithmetic operators
+
+		public static Flow operator -(Flow right)
+		{
+			return new Flow(-right.CubicMeterPerSecond);
+		}
+
+		public static Flow operator +(Flow left, Flow right)
+		{
+			return new Flow(left.CubicMeterPerSecond + right.CubicMeterPerSecond);
+		}
+
+		public static Flow operator -(Flow left, Flow right)
+		{
+			return new Flow(left.CubicMeterPerSecond - right.CubicMeterPerSecond);
+		}
+
+		public static Flow operator *(double left, Flow right)
+		{
+			return new Flow(left * right.CubicMeterPerSecond);
+		}
+
+		public static Flow operator *(Flow left, double right)
+		{
+			return new Flow(left.CubicMeterPerSecond * right);
+		}
+
+		public static Flow operator /(Flow left, double right)
+		{
+			return new Flow(left.CubicMeterPerSecond / right);
+		}
+
+		public static double operator /(Flow left, Flow right)
+		{
+			return left.CubicMeterPerSecond / right.CubicMeterPerSecond;
+		}
+
+		#endregion
+
+		public override string ToString()
+		{
+			return CubicMeterPerSecond + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit.CubicMeterPerSecond);
+		}
+	}
+}

Src/UnitsNet/Pressure.cs

@@ -30,6 +30,7 @@ namespace UnitsNet
     public struct Pressure : IComparable, IComparable<Pressure>
     {
         private const double KpaToPaRatio = 1000;
+		private const double MpaToPaRatio = 1000000;
         private const double Nm2ToPaRatio = 1;
         private const double Ncm2ToPaRatio = 1E+4;
         private const double Nmm2ToPaRatio = 1E+6;
@@ -38,6 +39,7 @@ public struct Pressure : IComparable, IComparable<Pressure>
         private const double AtmToPaRatio = 101325;
         private const double TorrToPaRatio = 1.3332266752*1E2;
         private const double PsiToPaRatio = 6.89464975179*1E3;
+		private const double KFSCToPaRatio = 98066.5;
 
         /// <summary>
         ///     Pressure in pascal.
@@ -56,6 +58,16 @@ public double KiloPascals
             get { return Pascals/KpaToPaRatio; }
         }
 
+		public double MegaPascals
+		{
+			get { return Pascals / MpaToPaRatio; }
+		}
+
+	    public double KilogramForcePerSquareCentimeter
+	    {
+			get { return Pascals / KFSCToPaRatio; }
+	    }
+
         public double NewtonsPerSquareMeter
         {
             get { return Pascals/Nm2ToPaRatio; }
@@ -131,6 +143,16 @@ public static Pressure FromKiloPascals(double kpa)
             return new Pressure(KpaToPaRatio*kpa);
         }
 
+		public static Pressure FromMegaPascals(double mpa)
+		{
+			return new Pressure(MpaToPaRatio * mpa);
+		}
+
+		public static Pressure FromKilogramForcePerSquareCentimeter(double kfsc)
+		{
+			return new Pressure(KFSCToPaRatio * kfsc);
+		}
+
         public static Pressure FromNewtonsPerSquareCentimeter(double nsc)
         {
             return new Pressure(Ncm2ToPaRatio*nsc);

Src/UnitsNet/Revolution.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Globalization;
+
+namespace UnitsNet
+{
+	/// <summary>
+	///     A class for representing revolution.
+	/// </summary>
+	public struct Revolution : IComparable, IComparable<Revolution>
+	{
+		private const double MinuteToSecondRatio = 0.0166666666666667;
+		private const double SecondToMinuteRatio = 60;
+
+		public readonly double RevolutionsPerSecond;
+
+		private Revolution(double revolutionsPerSecond)
+			: this()
+		{
+			RevolutionsPerSecond = revolutionsPerSecond;
+		}
+
+		public double RevolutionsPerMinute
+		{
+			get { return RevolutionsPerSecond * SecondToMinuteRatio; }
+		}
+
+		#region Static
+
+		public static Revolution Zero
+		{
+			get { return new Revolution(); }
+		}
+
+		public static Revolution FromRevolutionsPerMinute(double revolutionsPerMinute)
+		{
+			return new Revolution(revolutionsPerMinute * MinuteToSecondRatio);
+		}
+
+		public static Revolution FromRevolutionsPerSecond(double revolutionsPerSecond)
+		{
+			return new Revolution(revolutionsPerSecond);
+		}
+
+		#endregion
+
+		#region Equality / IComparable
+
+		public int CompareTo(object obj)
+		{
+			if (obj == null) throw new ArgumentNullException("obj");
+			if (!(obj is Revolution)) throw new ArgumentException("Expected type Revolution.", "obj");
+			return CompareTo((Revolution)obj);
+		}
+
+		public int CompareTo(Revolution other)
+		{
+			return RevolutionsPerSecond.CompareTo(other.RevolutionsPerSecond);
+		}
+
+		public static bool operator <=(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond <= right.RevolutionsPerSecond;
+		}
+
+		public static bool operator >=(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond >= right.RevolutionsPerSecond;
+		}
+
+		public static bool operator <(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond < right.RevolutionsPerSecond;
+		}
+
+		public static bool operator >(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond > right.RevolutionsPerSecond;
+		}
+
+		public static bool operator ==(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond == right.RevolutionsPerSecond;
+		}
+
+		public static bool operator !=(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond != right.RevolutionsPerSecond;
+		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null || GetType() != obj.GetType())
+			{
+				return false;
+			}
+
+			return RevolutionsPerSecond.Equals(((Revolution)obj).RevolutionsPerSecond);
+		}
+
+		public override int GetHashCode()
+		{
+			return RevolutionsPerSecond.GetHashCode();
+		}
+		#endregion
+
+		#region Arithmetic operators
+
+		public static Revolution operator -(Revolution right)
+		{
+			return new Revolution(-right.RevolutionsPerSecond);
+		}
+
+		public static Revolution operator +(Revolution left, Revolution right)
+		{
+			return new Revolution(left.RevolutionsPerSecond + right.RevolutionsPerSecond);
+		}
+
+		public static Revolution operator -(Revolution left, Revolution right)
+		{
+			return new Revolution(left.RevolutionsPerSecond - right.RevolutionsPerSecond);
+		}
+
+		public static Revolution operator *(double left, Revolution right)
+		{
+			return new Revolution(left * right.RevolutionsPerSecond);
+		}
+
+		public static Revolution operator *(Revolution left, double right)
+		{
+			return new Revolution(left.RevolutionsPerSecond * right);
+		}
+
+		public static Revolution operator /(Revolution left, double right)
+		{
+			return new Revolution(left.RevolutionsPerSecond / right);
+		}
+
+		public static double operator /(Revolution left, Revolution right)
+		{
+			return left.RevolutionsPerSecond / right.RevolutionsPerSecond;
+		}
+
+		#endregion
+
+		public override string ToString()
+		{
+			return RevolutionsPerSecond + " " + UnitSystem.Create(CultureInfo.CurrentCulture).GetDefaultAbbreviation(Unit.RevolutionsPerSecond);
+		}
+	}
+}

Src/UnitsNet/Unit.cs

@@ -70,14 +70,16 @@ public enum Unit
         // Pressure
         Pascal,
         KiloPascal,
+		MegaPascal,
         Psi,
         NewtonPerSquareCentimeter,
         NewtonPerSquareMillimeter,
         NewtonPerSquareMeter,
-        Bar,
+		Bar,
         TechnicalAtmosphere,
         Atmosphere,
         Torr,
+		KilogramForcePerSquareCentimeter,
 
         // Force
         Kilonewton,
@@ -162,6 +164,14 @@ public enum Unit
         // Cooking units
         Tablespoon,
         Teaspoon,
+
+		// Flow
+		CubicMeterPerSecond,
+		CubicMeterPerHour,
+
+		// Revolution
+		RevolutionsPerSecond,
+		RevolutionsPerMinute,
     }
 
     //public enum LengthUnit