From d812c26ee50afcbbdcc42d468436af296965d85c Mon Sep 17 00:00:00 2001
From: Johan Larsson <johan_gavle1@hotmail.com>
Date: Sat, 18 Oct 2014 23:56:16 +0200
Subject: [PATCH] added /rad to torque

---
 .../Gu.Units.Generator.Tests.csproj           |   9 -
 Gu.Units.Generator/App.xaml                   |  10 +-
 Gu.Units.Generator/GeneratorSettings.xml      |   6 +-
 Gu.Units.Generator/MainWindow.xaml            |  10 +-
 Gu.Units.Generator/Templates/Quantity.tt      |  12 +
 .../Templates/QuantityGenerator.txt           |  27 +-
 .../Templates/UnitGenerator.txt               |  27 +-
 Gu.Units.Tests/ArithmeticsTests.cs            |   1 -
 Gu.Units.Tests/Gu.Units.Tests.csproj          |   8 -
 Gu.Units.sln                                  |   1 -
 Gu.Units/Acceleration.generated.cs            | 433 ++++++++++++++++
 Gu.Units/AccelerationUnit.generated.cs        |  79 +++
 Gu.Units/Angle.generated.cs                   |  10 +
 ...generated.cs => AngularSpeed.generated.cs} | 196 ++++----
 ...rated.cs => AngularSpeedUnit.generated.cs} |  12 +-
 Gu.Units/Area.generated.cs                    |  15 +
 Gu.Units/Current.generated.cs                 | 458 +++++++++++++++++
 Gu.Units/CurrentUnit.generated.cs             | 116 +++++
 Gu.Units/Density.generated.cs                 |   5 +
 Gu.Units/Energy.generated.cs                  |  30 ++
 Gu.Units/Force.generated.cs                   |  30 ++
 Gu.Units/Frequency.generated.cs               |  25 +
 Gu.Units/Gu.Units.csproj                      |  46 +-
 Gu.Units/Interfaces/IQuantity.cs              |  13 +
 Gu.Units/Length.generated.cs                  |  25 +
 Gu.Units/Mass.generated.cs                    |  15 +
 Gu.Units/Power.generated.cs                   |  30 ++
 Gu.Units/Pressure.generated.cs                |  15 +
 Gu.Units/Resistance.generated.cs              | 463 +++++++++++++++++
 Gu.Units/ResistanceUnit.generated.cs          | 116 +++++
 Gu.Units/Speed.generated.cs                   |  30 ++
 Gu.Units/Stiffness.generated.cs               | 393 +++++++++++++++
 Gu.Units/StiffnessUnit.generated.cs           |  67 +++
 Gu.Units/Time.generated.cs                    |  15 +
 Gu.Units/Torque.generated.cs                  | 388 +++++++++++++++
 Gu.Units/TorqueUnit.generated.cs              |  67 +++
 Gu.Units/Voltage.generated.cs                 | 468 ++++++++++++++++++
 Gu.Units/VoltageUnit.generated.cs             | 116 +++++
 Gu.Units/Volume.generated.cs                  |  20 +
 Gu.Units/VolumetricFlow.generated.cs          | 398 +++++++++++++++
 Gu.Units/VolumetricFlowUnit.generated.cs      |  67 +++
 41 files changed, 4138 insertions(+), 134 deletions(-)
 create mode 100644 Gu.Units/Acceleration.generated.cs
 create mode 100644 Gu.Units/AccelerationUnit.generated.cs
 rename Gu.Units/{AngularVelocity.generated.cs => AngularSpeed.generated.cs} (60%)
 rename Gu.Units/{AngularVelocityUnit.generated.cs => AngularSpeedUnit.generated.cs} (78%)
 create mode 100644 Gu.Units/Current.generated.cs
 create mode 100644 Gu.Units/CurrentUnit.generated.cs
 create mode 100644 Gu.Units/Resistance.generated.cs
 create mode 100644 Gu.Units/ResistanceUnit.generated.cs
 create mode 100644 Gu.Units/Stiffness.generated.cs
 create mode 100644 Gu.Units/StiffnessUnit.generated.cs
 create mode 100644 Gu.Units/Torque.generated.cs
 create mode 100644 Gu.Units/TorqueUnit.generated.cs
 create mode 100644 Gu.Units/Voltage.generated.cs
 create mode 100644 Gu.Units/VoltageUnit.generated.cs
 create mode 100644 Gu.Units/VolumetricFlow.generated.cs
 create mode 100644 Gu.Units/VolumetricFlowUnit.generated.cs

diff --git a/Gu.Units.Generator.Tests/Gu.Units.Generator.Tests.csproj b/Gu.Units.Generator.Tests/Gu.Units.Generator.Tests.csproj
index 6d072f1e..b8b4161e 100644
--- a/Gu.Units.Generator.Tests/Gu.Units.Generator.Tests.csproj
+++ b/Gu.Units.Generator.Tests/Gu.Units.Generator.Tests.csproj
@@ -37,11 +37,6 @@
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="MockSettings.cs" />
@@ -59,10 +54,6 @@
       <Project>{E2703762-7D3C-49AE-B8A8-B3A792F018E3}</Project>
       <Name>Gu.Units.Generator</Name>
     </ProjectReference>
-    <ProjectReference Include="..\Gu.Units\Gu.Units.csproj">
-      <Project>{F1F8B138-BECC-4475-A7AB-B3019338BC7B}</Project>
-      <Name>Gu.Units</Name>
-    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
diff --git a/Gu.Units.Generator/App.xaml b/Gu.Units.Generator/App.xaml
index 6dba0ccf..2f9dac64 100644
--- a/Gu.Units.Generator/App.xaml
+++ b/Gu.Units.Generator/App.xaml
@@ -3,9 +3,9 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:generator="clr-namespace:Gu.Units.Generator"
              StartupUri="MainWindow.xaml">
-    <Application.Resources >
+    <Application.Resources>
         <GroupStyle x:Key="GroupStyle">
-            <GroupStyle.HeaderTemplate >
+            <GroupStyle.HeaderTemplate>
                 <DataTemplate DataType="{x:Type generator:IUnit}">
                     <StackPanel>
                         <TextBlock Text="{Binding QuantityName}" />
@@ -16,13 +16,13 @@
                 <Style TargetType="{x:Type GroupItem}">
                     <Setter Property="Template">
                         <Setter.Value>
-                            <ControlTemplate TargetType="{x:Type GroupItem}" >
+                            <ControlTemplate TargetType="{x:Type GroupItem}">
                                 <Expander>
                                     <Expander.Header>
                                         <StackPanel Orientation="Horizontal">
                                             <TextBlock Text="{Binding QuantityName}" />
-                                            <TextBlock Text="{Binding Path=ItemCount}"/>
-                                            <TextBlock Text="Items"/>
+                                            <TextBlock Text="{Binding Path=ItemCount}" />
+                                            <TextBlock Text="Items" />
                                         </StackPanel>
                                     </Expander.Header>
                                     <ItemsPresenter />
diff --git a/Gu.Units.Generator/GeneratorSettings.xml b/Gu.Units.Generator/GeneratorSettings.xml
index 893054e9..40fbe58f 100644
--- a/Gu.Units.Generator/GeneratorSettings.xml
+++ b/Gu.Units.Generator/GeneratorSettings.xml
@@ -415,7 +415,7 @@
       <Namespace>Gu.Units</Namespace>
       <ClassName>RadiansPerSecond</ClassName>
       <Symbol>rad/s</Symbol>
-      <QuantityName>AngularVelocity</QuantityName>
+      <QuantityName>AngularSpeed</QuantityName>
       <SubUnits />
       <Parts>
         <UnitAndPower>
@@ -514,6 +514,10 @@
           <UnitName>Metres</UnitName>
           <Power>1</Power>
         </UnitAndPower>
+        <UnitAndPower>
+          <UnitName>Radians</UnitName>
+          <Power>-1</Power>
+        </UnitAndPower>
       </Parts>
       <ExplicitName>false</ExplicitName>
     </DerivedUnit>
diff --git a/Gu.Units.Generator/MainWindow.xaml b/Gu.Units.Generator/MainWindow.xaml
index 018adfc1..5859100f 100644
--- a/Gu.Units.Generator/MainWindow.xaml
+++ b/Gu.Units.Generator/MainWindow.xaml
@@ -29,6 +29,7 @@
         <Grid>
             <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="5" />
                 <ColumnDefinition Width="Auto" />
                 <ColumnDefinition />
             </Grid.ColumnDefinitions>
@@ -73,8 +74,13 @@
                     </GroupBox>
                 </Grid>
             </GroupBox>
-
-            <GroupBox Grid.Column="1" Header="Conversions">
+            
+            <GridSplitter Grid.Column="1"
+                          HorizontalAlignment="Stretch"
+                          VerticalAlignment="Stretch"
+                          ResizeDirection="Columns" />
+            
+            <GroupBox Grid.Column="2" Header="Conversions">
                 <Grid>
                     <Grid.RowDefinitions>
                         <RowDefinition />
diff --git a/Gu.Units.Generator/Templates/Quantity.tt b/Gu.Units.Generator/Templates/Quantity.tt
index 5151c333..9a54d76b 100644
--- a/Gu.Units.Generator/Templates/Quantity.tt
+++ b/Gu.Units.Generator/Templates/Quantity.tt
@@ -140,6 +140,18 @@ namespace <#= quantity.Namespace #>
             return From(<#= su.ParameterName #>, <#= quantity.ClassName #>Unit.<#= su.ClassName #>);
         }
 
+<#
+		} 
+		#>
+<#
+		foreach(var op in quantity.OperatorOverloads)
+		{
+		#>
+        public static <#= op.Result.ClassName #> operator<#= op.Operator #>(<#= op.Left.ClassName #> left, <#= op.Right.ClassName #> right)
+        {
+            return <#= op.Result.ClassName #>.From<#= op.Result.Unit.ClassName #>(left.<#= op.Left.Unit.ClassName #> <#= op.Operator #> right.<#= op.Right.Unit.ClassName #>);
+        }
+
 <#
 		} 
 		#>
diff --git a/Gu.Units.Generator/Templates/QuantityGenerator.txt b/Gu.Units.Generator/Templates/QuantityGenerator.txt
index cea407d7..61841c26 100644
--- a/Gu.Units.Generator/Templates/QuantityGenerator.txt
+++ b/Gu.Units.Generator/Templates/QuantityGenerator.txt
@@ -1,11 +1,15 @@
 
-Read Settings found 16 units
+Read Settings found 23 units
+//-> Acceleration.generated.cs
+
 //-> Angle.generated.cs
 
-//-> AngularVelocity.generated.cs
+//-> AngularSpeed.generated.cs
 
 //-> Area.generated.cs
 
+//-> Current.generated.cs
+
 //-> Density.generated.cs
 
 //-> Energy.generated.cs
@@ -24,18 +28,34 @@ Read Settings found 16 units
 
 //-> Pressure.generated.cs
 
+//-> Resistance.generated.cs
+
 //-> Speed.generated.cs
 
+//-> Stiffness.generated.cs
+
 //-> Temperature.generated.cs
 
 //-> Time.generated.cs
 
+//-> Torque.generated.cs
+
+//-> Voltage.generated.cs
+
 //-> Volume.generated.cs
+
+//-> VolumetricFlow.generated.cs
 // Generated helper templates
 // Gu.Units\Gu.Units\QuantityGenerator.txt4
 // Generated items
+// Gu.Units\Gu.Units\Resistance.generated.cs
+// Gu.Units\Gu.Units\Voltage.generated.cs
+// Gu.Units\Gu.Units\VolumetricFlow.generated.cs
+// Gu.Units\Gu.Units\Stiffness.generated.cs
+// Gu.Units\Gu.Units\Torque.generated.cs
+// Gu.Units\Gu.Units\Acceleration.generated.cs
 // Gu.Units\Gu.Units\Frequency.generated.cs
-// Gu.Units\Gu.Units\AngularVelocity.generated.cs
+// Gu.Units\Gu.Units\AngularSpeed.generated.cs
 // Gu.Units\Gu.Units\Speed.generated.cs
 // Gu.Units\Gu.Units\Power.generated.cs
 // Gu.Units\Gu.Units\Energy.generated.cs
@@ -44,6 +64,7 @@ Read Settings found 16 units
 // Gu.Units\Gu.Units\Force.generated.cs
 // Gu.Units\Gu.Units\Volume.generated.cs
 // Gu.Units\Gu.Units\Area.generated.cs
+// Gu.Units\Gu.Units\Current.generated.cs
 // Gu.Units\Gu.Units\Fraction.generated.cs
 // Gu.Units\Gu.Units\Angle.generated.cs
 // Gu.Units\Gu.Units\Temperature.generated.cs
diff --git a/Gu.Units.Generator/Templates/UnitGenerator.txt b/Gu.Units.Generator/Templates/UnitGenerator.txt
index 7cc6120c..59a11449 100644
--- a/Gu.Units.Generator/Templates/UnitGenerator.txt
+++ b/Gu.Units.Generator/Templates/UnitGenerator.txt
@@ -1,11 +1,15 @@
 
-Read Settings found 6 units
+Read Settings found 7 units
+//-> AccelerationUnit.generated.cs
+
 //-> AngleUnit.generated.cs
 
-//-> AngularVelocityUnit.generated.cs
+//-> AngularSpeedUnit.generated.cs
 
 //-> AreaUnit.generated.cs
 
+//-> CurrentUnit.generated.cs
+
 //-> DensityUnit.generated.cs
 
 //-> EnergyUnit.generated.cs
@@ -24,18 +28,34 @@ Read Settings found 6 units
 
 //-> PressureUnit.generated.cs
 
+//-> ResistanceUnit.generated.cs
+
 //-> SpeedUnit.generated.cs
 
+//-> StiffnessUnit.generated.cs
+
 //-> TemperatureUnit.generated.cs
 
 //-> TimeUnit.generated.cs
 
+//-> TorqueUnit.generated.cs
+
+//-> VoltageUnit.generated.cs
+
+//-> VolumetricFlowUnit.generated.cs
+
 //-> VolumeUnit.generated.cs
 // Generated helper templates
 // Gu.Units\Gu.Units\UnitGenerator.txt4
 // Generated items
+// Gu.Units\Gu.Units\ResistanceUnit.generated.cs
+// Gu.Units\Gu.Units\VoltageUnit.generated.cs
+// Gu.Units\Gu.Units\VolumetricFlowUnit.generated.cs
+// Gu.Units\Gu.Units\StiffnessUnit.generated.cs
+// Gu.Units\Gu.Units\TorqueUnit.generated.cs
+// Gu.Units\Gu.Units\AccelerationUnit.generated.cs
 // Gu.Units\Gu.Units\FrequencyUnit.generated.cs
-// Gu.Units\Gu.Units\AngularVelocityUnit.generated.cs
+// Gu.Units\Gu.Units\AngularSpeedUnit.generated.cs
 // Gu.Units\Gu.Units\SpeedUnit.generated.cs
 // Gu.Units\Gu.Units\PowerUnit.generated.cs
 // Gu.Units\Gu.Units\EnergyUnit.generated.cs
@@ -44,6 +64,7 @@ Read Settings found 6 units
 // Gu.Units\Gu.Units\ForceUnit.generated.cs
 // Gu.Units\Gu.Units\VolumeUnit.generated.cs
 // Gu.Units\Gu.Units\AreaUnit.generated.cs
+// Gu.Units\Gu.Units\CurrentUnit.generated.cs
 // Gu.Units\Gu.Units\FractionUnit.generated.cs
 // Gu.Units\Gu.Units\AngleUnit.generated.cs
 // Gu.Units\Gu.Units\TemperatureUnit.generated.cs
diff --git a/Gu.Units.Tests/ArithmeticsTests.cs b/Gu.Units.Tests/ArithmeticsTests.cs
index 8fa084fd..33bc59fa 100644
--- a/Gu.Units.Tests/ArithmeticsTests.cs
+++ b/Gu.Units.Tests/ArithmeticsTests.cs
@@ -1,6 +1,5 @@
 namespace Gu.Units.Tests
 {
-    using Moq;
     using NUnit.Framework;
 
     //public class ArithmeticsTests
diff --git a/Gu.Units.Tests/Gu.Units.Tests.csproj b/Gu.Units.Tests/Gu.Units.Tests.csproj
index 4aab01e7..c4f7b184 100644
--- a/Gu.Units.Tests/Gu.Units.Tests.csproj
+++ b/Gu.Units.Tests/Gu.Units.Tests.csproj
@@ -42,19 +42,11 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Moq">
-      <HintPath>..\packages\Moq.4.2.1409.1722\lib\net40\Moq.dll</HintPath>
-    </Reference>
     <Reference Include="nunit.framework">
       <HintPath>..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="ArithmeticsTests.cs" />
diff --git a/Gu.Units.sln b/Gu.Units.sln
index 1521a0c2..a0f9631a 100644
--- a/Gu.Units.sln
+++ b/Gu.Units.sln
@@ -45,7 +45,6 @@ Global
 		{9785A89E-8B39-48BA-8C0A-BEB7D761D402}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{9785A89E-8B39-48BA-8C0A-BEB7D761D402}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9785A89E-8B39-48BA-8C0A-BEB7D761D402}.Generator Only|Any CPU.ActiveCfg = Release|Any CPU
-		{9785A89E-8B39-48BA-8C0A-BEB7D761D402}.Generator Only|Any CPU.Build.0 = Release|Any CPU
 		{9785A89E-8B39-48BA-8C0A-BEB7D761D402}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9785A89E-8B39-48BA-8C0A-BEB7D761D402}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
diff --git a/Gu.Units/Acceleration.generated.cs b/Gu.Units/Acceleration.generated.cs
new file mode 100644
index 00000000..eef48f83
--- /dev/null
+++ b/Gu.Units/Acceleration.generated.cs
@@ -0,0 +1,433 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.Acceleration"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct Acceleration : IComparable<Acceleration>, IEquatable<Acceleration>, IFormattable, IXmlSerializable, IQuantity<LengthUnit, I1, TimeUnit, INeg2>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.MetresPerSecondSquared"/>.
+        /// </summary>
+        public readonly double MetresPerSecondSquared;
+
+        private Acceleration(double metresPerSecondSquared)
+        {
+            MetresPerSecondSquared = metresPerSecondSquared;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.MetresPerSecondSquared"/>.</param>
+        public Acceleration(double value, AccelerationUnit unit)
+        {
+            MetresPerSecondSquared = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in MetresPerSecondSquared
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return MetresPerSecondSquared;
+            }
+        }
+
+        /// <summary>
+        /// The quantity in millimetresPerSecondSquared
+        /// </summary>
+        public double MillimetresPerSecondSquared
+        {
+            get
+            {
+                return AccelerationUnit.MillimetresPerSecondSquared.FromSiUnit(MetresPerSecondSquared);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in centimetresPerSecondSquared
+        /// </summary>
+        public double CentimetresPerSecondSquared
+        {
+            get
+            {
+                return AccelerationUnit.CentimetresPerSecondSquared.FromSiUnit(MetresPerSecondSquared);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.Acceleration"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.Acceleration"/></param>
+        /// <returns></returns>
+        public static Acceleration Parse(string s)
+        {
+            return Parser.Parse<AccelerationUnit, Acceleration>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.Acceleration"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.Acceleration"/></returns>
+        public static Acceleration ReadFrom(XmlReader reader)
+        {
+            var v = new Acceleration();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static Acceleration From(double value, AccelerationUnit unit)
+        {
+            return new Acceleration(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <param name="metresPerSecondSquared">The value in <see cref="T:Gu.Units.MetresPerSecondSquared"/></param>
+        public static Acceleration FromMetresPerSecondSquared(double metresPerSecondSquared)
+        {
+            return new Acceleration(metresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <param name="millimetresPerSecondSquared">The value in mm / s^2</param>
+        public static Acceleration FromMillimetresPerSecondSquared(double millimetresPerSecondSquared)
+        {
+            return From(millimetresPerSecondSquared, AccelerationUnit.MillimetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <param name="centimetresPerSecondSquared">The value in cm / s^2</param>
+        public static Acceleration FromCentimetresPerSecondSquared(double centimetresPerSecondSquared)
+        {
+            return From(centimetresPerSecondSquared, AccelerationUnit.CentimetresPerSecondSquared);
+        }
+
+        public static Force operator *(Acceleration left, Mass right)
+        {
+            return Force.FromNewtons(left.MetresPerSecondSquared * right.Kilograms);
+        }
+
+        public static Speed operator *(Acceleration left, Time right)
+        {
+            return Speed.FromMetresPerSecond(left.MetresPerSecondSquared * right.Seconds);
+        }
+
+        public static Frequency operator /(Acceleration left, Speed right)
+        {
+            return Frequency.FromHertz(left.MetresPerSecondSquared / right.MetresPerSecond);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Acceleration"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Acceleration"/>.</param>
+        public static bool operator ==(Acceleration left, Acceleration right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Acceleration"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Acceleration"/>.</param>
+        public static bool operator !=(Acceleration left, Acceleration right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Acceleration"/> is less than another specified <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        public static bool operator <(Acceleration left, Acceleration right)
+        {
+            return left.MetresPerSecondSquared < right.MetresPerSecondSquared;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Acceleration"/> is greater than another specified <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        public static bool operator >(Acceleration left, Acceleration right)
+        {
+            return left.MetresPerSecondSquared > right.MetresPerSecondSquared;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Acceleration"/> is less than or equal to another specified <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        public static bool operator <=(Acceleration left, Acceleration right)
+        {
+            return left.MetresPerSecondSquared <= right.MetresPerSecondSquared;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Acceleration"/> is greater than or equal to another specified <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Acceleration"/>.</param>
+        public static bool operator >=(Acceleration left, Acceleration right)
+        {
+            return left.MetresPerSecondSquared >= right.MetresPerSecondSquared;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Acceleration"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.Acceleration"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Acceleration"/> with <paramref name="left"/> and returns the result.</returns>
+        public static Acceleration operator *(double left, Acceleration right)
+        {
+            return new Acceleration(left * right.MetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Acceleration"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Acceleration"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Acceleration"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Acceleration operator *(Acceleration left, double right)
+        {
+            return new Acceleration(left.MetresPerSecondSquared * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.Acceleration"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Acceleration"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.Acceleration"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Acceleration operator /(Acceleration left, double right)
+        {
+            return new Acceleration(left.MetresPerSecondSquared / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.Acceleration"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Acceleration"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Acceleration"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static Acceleration operator +(Acceleration left, Acceleration right)
+        {
+            return new Acceleration(left.MetresPerSecondSquared + right.MetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Subtracts an Acceleration from another Acceleration and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Acceleration"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Acceleration"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Acceleration"/> (the subtrahend).</param>
+        public static Acceleration operator -(Acceleration left, Acceleration right)
+        {
+            return new Acceleration(left.MetresPerSecondSquared - right.MetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.Acceleration"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Acceleration"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="Acceleration">A <see cref="T:Gu.Units.Acceleration"/></param>
+        public static Acceleration operator -(Acceleration Acceleration)
+        {
+            return new Acceleration(-1 * Acceleration.MetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.Acceleration"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="Acceleration"/>.
+        /// </returns>
+        /// <param name="Acceleration">A <see cref="T:Gu.Units.Acceleration"/></param>
+        public static Acceleration operator +(Acceleration Acceleration)
+        {
+            return Acceleration;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, AccelerationUnit.MetresPerSecondSquared);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, AccelerationUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.MetresPerSecondSquared);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.Acceleration"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.Acceleration"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.Acceleration"/> object to compare to this instance.</param>
+        public int CompareTo(Acceleration quantity)
+        {
+            return this.MetresPerSecondSquared.CompareTo(quantity.MetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Acceleration"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Acceleration as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Acceleration"/> object to compare with this instance.</param>
+        public bool Equals(Acceleration other)
+        {
+            return this.MetresPerSecondSquared.Equals(other.MetresPerSecondSquared);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Acceleration"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Acceleration as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Acceleration"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(Acceleration other, double tolerance)
+        {
+            return Math.Abs(this.MetresPerSecondSquared - other.MetresPerSecondSquared) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is Acceleration && this.Equals((Acceleration)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.MetresPerSecondSquared.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.MetresPerSecondSquared, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.MetresPerSecondSquared);
+        }
+    }
+}
diff --git a/Gu.Units/AccelerationUnit.generated.cs b/Gu.Units/AccelerationUnit.generated.cs
new file mode 100644
index 00000000..1625b1e8
--- /dev/null
+++ b/Gu.Units/AccelerationUnit.generated.cs
@@ -0,0 +1,79 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.AccelerationUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct AccelerationUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.MetresPerSecondSquared"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly AccelerationUnit MetresPerSecondSquared = new AccelerationUnit(1.0, "m/s²");
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.MillimetresPerSecondSquared"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly AccelerationUnit MillimetresPerSecondSquared = new AccelerationUnit(1E-06, "mm / s^2");
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.CentimetresPerSecondSquared"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly AccelerationUnit CentimetresPerSecondSquared = new AccelerationUnit(0.0001, "cm / s^2");
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public AccelerationUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.MetresPerSecondSquared"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static Acceleration operator *(double left, AccelerationUnit right)
+        {
+            return Acceleration.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.MetresPerSecondSquared"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from MetresPerSecondSquared.
+        /// </summary>
+        /// <param name="value">The value in MetresPerSecondSquared</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), MetresPerSecondSquared.Symbol);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gu.Units/Angle.generated.cs b/Gu.Units/Angle.generated.cs
index 8b832816..a2c7c39c 100644
--- a/Gu.Units/Angle.generated.cs
+++ b/Gu.Units/Angle.generated.cs
@@ -105,6 +105,16 @@ public static Angle FromDegrees(double degrees)
             return From(degrees, AngleUnit.Degrees);
         }
 
+        public static Time operator /(Angle left, AngularSpeed right)
+        {
+            return Time.FromSeconds(left.Radians / right.RadiansPerSecond);
+        }
+
+        public static AngularSpeed operator /(Angle left, Time right)
+        {
+            return AngularSpeed.FromRadiansPerSecond(left.Radians / right.Seconds);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Angle"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/AngularVelocity.generated.cs b/Gu.Units/AngularSpeed.generated.cs
similarity index 60%
rename from Gu.Units/AngularVelocity.generated.cs
rename to Gu.Units/AngularSpeed.generated.cs
index f8e00c4e..8586e10b 100644
--- a/Gu.Units/AngularVelocity.generated.cs
+++ b/Gu.Units/AngularSpeed.generated.cs
@@ -8,27 +8,27 @@
     using System.Xml.Serialization;
 
     /// <summary>
-    /// A type for the quantity <see cref="T:Gu.Units.AngularVelocity"/>.
+    /// A type for the quantity <see cref="T:Gu.Units.AngularSpeed"/>.
     /// </summary>
     [Serializable]
-    public partial struct AngularVelocity : IComparable<AngularVelocity>, IEquatable<AngularVelocity>, IFormattable, IXmlSerializable, IQuantity<AngleUnit, I1, TimeUnit, INeg1>
+    public partial struct AngularSpeed : IComparable<AngularSpeed>, IEquatable<AngularSpeed>, IFormattable, IXmlSerializable, IQuantity<AngleUnit, I1, TimeUnit, INeg1>
     {
         /// <summary>
         /// The quantity in <see cref="T:Gu.Units.RadiansPerSecond"/>.
         /// </summary>
         public readonly double RadiansPerSecond;
 
-        private AngularVelocity(double radiansPerSecond)
+        private AngularSpeed(double radiansPerSecond)
         {
             RadiansPerSecond = radiansPerSecond;
         }
 
         /// <summary>
-        /// Initializes a new instance of <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Initializes a new instance of <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <param name="value"></param>
         /// <param name="unit"><see cref="T:Gu.Units.RadiansPerSecond"/>.</param>
-        public AngularVelocity(double value, AngularVelocityUnit unit)
+        public AngularSpeed(double value, AngularSpeedUnit unit)
         {
             RadiansPerSecond = unit.ToSiUnit(value);
         }
@@ -45,205 +45,215 @@ public double SiValue
         }
 
         /// <summary>
-        /// Creates an instance of <see cref="T:Gu.Units.AngularVelocity"/> from its string representation
+        /// Creates an instance of <see cref="T:Gu.Units.AngularSpeed"/> from its string representation
         /// </summary>
-        /// <param name="s">The string representation of the <see cref="T:Gu.Units.AngularVelocity"/></param>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.AngularSpeed"/></param>
         /// <returns></returns>
-        public static AngularVelocity Parse(string s)
+        public static AngularSpeed Parse(string s)
         {
-            return Parser.Parse<AngularVelocityUnit, AngularVelocity>(s, From);
+            return Parser.Parse<AngularSpeedUnit, AngularSpeed>(s, From);
         }
 
         /// <summary>
-        /// Reads an instance of <see cref="T:Gu.Units.AngularVelocity"/> from the <paramref name="reader"/>
+        /// Reads an instance of <see cref="T:Gu.Units.AngularSpeed"/> from the <paramref name="reader"/>
         /// </summary>
         /// <param name="reader"></param>
-        /// <returns>An instance of  <see cref="T:Gu.Units.AngularVelocity"/></returns>
-        public static AngularVelocity ReadFrom(XmlReader reader)
+        /// <returns>An instance of  <see cref="T:Gu.Units.AngularSpeed"/></returns>
+        public static AngularSpeed ReadFrom(XmlReader reader)
         {
-            var v = new AngularVelocity();
+            var v = new AngularSpeed();
             v.ReadXml(reader);
             return v;
         }
 
         /// <summary>
-        /// Creates a new instance of <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Creates a new instance of <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <param name="value"></param>
         /// <param name="unit"></param>
-        public static AngularVelocity From(double value, AngularVelocityUnit unit)
+        public static AngularSpeed From(double value, AngularSpeedUnit unit)
         {
-            return new AngularVelocity(unit.ToSiUnit(value));
+            return new AngularSpeed(unit.ToSiUnit(value));
         }
 
         /// <summary>
-        /// Creates a new instance of <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Creates a new instance of <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <param name="radiansPerSecond">The value in <see cref="T:Gu.Units.RadiansPerSecond"/></param>
-        public static AngularVelocity FromRadiansPerSecond(double radiansPerSecond)
+        public static AngularSpeed FromRadiansPerSecond(double radiansPerSecond)
         {
-            return new AngularVelocity(radiansPerSecond);
+            return new AngularSpeed(radiansPerSecond);
+        }
+
+        public static Angle operator *(AngularSpeed left, Time right)
+        {
+            return Angle.FromRadians(left.RadiansPerSecond * right.Seconds);
+        }
+
+        public static Frequency operator /(AngularSpeed left, Angle right)
+        {
+            return Frequency.FromHertz(left.RadiansPerSecond / right.Radians);
         }
 
         /// <summary>
-        /// Indicates whether two <see cref="T:Gu.Units.AngularVelocity"/> instances are equal.
+        /// Indicates whether two <see cref="T:Gu.Units.AngularSpeed"/> instances are equal.
         /// </summary>
         /// <returns>
         /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
         /// </returns>
-        /// <param name="left">A <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        /// <param name="right">A <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        public static bool operator ==(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">A <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        public static bool operator ==(AngularSpeed left, AngularSpeed right)
         {
             return left.Equals(right);
         }
 
         /// <summary>
-        /// Indicates whether two <see cref="T:Gu.Units.AngularVelocity"/> instances are not equal.
+        /// Indicates whether two <see cref="T:Gu.Units.AngularSpeed"/> instances are not equal.
         /// </summary>
         /// <returns>
         /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
         /// </returns>
-        /// <param name="left">A <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        /// <param name="right">A <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        public static bool operator !=(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">A <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        public static bool operator !=(AngularSpeed left, AngularSpeed right)
         {
             return !left.Equals(right);
         }
 
         /// <summary>
-        /// Indicates whether a specified <see cref="T:Gu.Units.AngularVelocity"/> is less than another specified <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Indicates whether a specified <see cref="T:Gu.Units.AngularSpeed"/> is less than another specified <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <returns>
         /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
         /// </returns>
-        /// <param name="left">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        /// <param name="right">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        public static bool operator <(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        public static bool operator <(AngularSpeed left, AngularSpeed right)
         {
             return left.RadiansPerSecond < right.RadiansPerSecond;
         }
 
         /// <summary>
-        /// Indicates whether a specified <see cref="T:Gu.Units.AngularVelocity"/> is greater than another specified <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Indicates whether a specified <see cref="T:Gu.Units.AngularSpeed"/> is greater than another specified <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <returns>
         /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
         /// </returns>
-        /// <param name="left">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        /// <param name="right">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        public static bool operator >(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        public static bool operator >(AngularSpeed left, AngularSpeed right)
         {
             return left.RadiansPerSecond > right.RadiansPerSecond;
         }
 
         /// <summary>
-        /// Indicates whether a specified <see cref="T:Gu.Units.AngularVelocity"/> is less than or equal to another specified <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Indicates whether a specified <see cref="T:Gu.Units.AngularSpeed"/> is less than or equal to another specified <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <returns>
         /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
         /// </returns>
-        /// <param name="left">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        /// <param name="right">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        public static bool operator <=(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        public static bool operator <=(AngularSpeed left, AngularSpeed right)
         {
             return left.RadiansPerSecond <= right.RadiansPerSecond;
         }
 
         /// <summary>
-        /// Indicates whether a specified <see cref="T:Gu.Units.AngularVelocity"/> is greater than or equal to another specified <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Indicates whether a specified <see cref="T:Gu.Units.AngularSpeed"/> is greater than or equal to another specified <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <returns>
         /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
         /// </returns>
-        /// <param name="left">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        /// <param name="right">An <see cref="T:Gu.Units.AngularVelocity"/>.</param>
-        public static bool operator >=(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.AngularSpeed"/>.</param>
+        public static bool operator >=(AngularSpeed left, AngularSpeed right)
         {
             return left.RadiansPerSecond >= right.RadiansPerSecond;
         }
 
         /// <summary>
-        /// Multiplies an instance of <see cref="T:Gu.Units.AngularVelocity"/> with <paramref name="left"/> and returns the result.
+        /// Multiplies an instance of <see cref="T:Gu.Units.AngularSpeed"/> with <paramref name="left"/> and returns the result.
         /// </summary>
-        /// <param name="right">An instance of <see cref="T:Gu.Units.AngularVelocity"/></param>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.AngularSpeed"/></param>
         /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
-        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.AngularVelocity"/> with <paramref name="left"/> and returns the result.</returns>
-        public static AngularVelocity operator *(double left, AngularVelocity right)
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.AngularSpeed"/> with <paramref name="left"/> and returns the result.</returns>
+        public static AngularSpeed operator *(double left, AngularSpeed right)
         {
-            return new AngularVelocity(left * right.RadiansPerSecond);
+            return new AngularSpeed(left * right.RadiansPerSecond);
         }
 
         /// <summary>
-        /// Multiplies an instance of <see cref="T:Gu.Units.AngularVelocity"/> with <paramref name="right"/> and returns the result.
+        /// Multiplies an instance of <see cref="T:Gu.Units.AngularSpeed"/> with <paramref name="right"/> and returns the result.
         /// </summary>
-        /// <param name="left">An instance of <see cref="T:Gu.Units.AngularVelocity"/></param>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.AngularSpeed"/></param>
         /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
-        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.AngularVelocity"/> with <paramref name="right"/> and returns the result.</returns>
-        public static AngularVelocity operator *(AngularVelocity left, double right)
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.AngularSpeed"/> with <paramref name="right"/> and returns the result.</returns>
+        public static AngularSpeed operator *(AngularSpeed left, double right)
         {
-            return new AngularVelocity(left.RadiansPerSecond * right);
+            return new AngularSpeed(left.RadiansPerSecond * right);
         }
 
         /// <summary>
-        /// Divides an instance of <see cref="T:Gu.Units.AngularVelocity"/> with <paramref name="right"/> and returns the result.
+        /// Divides an instance of <see cref="T:Gu.Units.AngularSpeed"/> with <paramref name="right"/> and returns the result.
         /// </summary>
-        /// <param name="left">An instance of <see cref="T:Gu.Units.AngularVelocity"/></param>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.AngularSpeed"/></param>
         /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
-        /// <returns>Divides an instance of <see cref="T:Gu.Units.AngularVelocity"/> with <paramref name="right"/> and returns the result.</returns>
-        public static AngularVelocity operator /(AngularVelocity left, double right)
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.AngularSpeed"/> with <paramref name="right"/> and returns the result.</returns>
+        public static AngularSpeed operator /(AngularSpeed left, double right)
         {
-            return new AngularVelocity(left.RadiansPerSecond / right);
+            return new AngularSpeed(left.RadiansPerSecond / right);
         }
 
         /// <summary>
-        /// Adds two specified <see cref="T:Gu.Units.AngularVelocity"/> instances.
+        /// Adds two specified <see cref="T:Gu.Units.AngularSpeed"/> instances.
         /// </summary>
         /// <returns>
-        /// An <see cref="T:Gu.Units.AngularVelocity"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// An <see cref="T:Gu.Units.AngularSpeed"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
         /// </returns>
-        /// <param name="left">A <see cref="T:Gu.Units.AngularVelocity"/>.</param>
+        /// <param name="left">A <see cref="T:Gu.Units.AngularSpeed"/>.</param>
         /// <param name="right">A TimeSpan.</param>
-        public static AngularVelocity operator +(AngularVelocity left, AngularVelocity right)
+        public static AngularSpeed operator +(AngularSpeed left, AngularSpeed right)
         {
-            return new AngularVelocity(left.RadiansPerSecond + right.RadiansPerSecond);
+            return new AngularSpeed(left.RadiansPerSecond + right.RadiansPerSecond);
         }
 
         /// <summary>
-        /// Subtracts an AngularVelocity from another AngularVelocity and returns the difference.
+        /// Subtracts an AngularSpeed from another AngularSpeed and returns the difference.
         /// </summary>
         /// <returns>
-        /// An <see cref="T:Gu.Units.AngularVelocity"/> that is the difference
+        /// An <see cref="T:Gu.Units.AngularSpeed"/> that is the difference
         /// </returns>
-        /// <param name="left">A <see cref="T:Gu.Units.AngularVelocity"/> (the minuend).</param>
-        /// <param name="right">A <see cref="T:Gu.Units.AngularVelocity"/> (the subtrahend).</param>
-        public static AngularVelocity operator -(AngularVelocity left, AngularVelocity right)
+        /// <param name="left">A <see cref="T:Gu.Units.AngularSpeed"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.AngularSpeed"/> (the subtrahend).</param>
+        public static AngularSpeed operator -(AngularSpeed left, AngularSpeed right)
         {
-            return new AngularVelocity(left.RadiansPerSecond - right.RadiansPerSecond);
+            return new AngularSpeed(left.RadiansPerSecond - right.RadiansPerSecond);
         }
 
         /// <summary>
-        /// Returns an <see cref="T:Gu.Units.AngularVelocity"/> whose quantity is the negated quantity of the specified instance.
+        /// Returns an <see cref="T:Gu.Units.AngularSpeed"/> whose quantity is the negated quantity of the specified instance.
         /// </summary>
         /// <returns>
-        /// An <see cref="T:Gu.Units.AngularVelocity"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// An <see cref="T:Gu.Units.AngularSpeed"/> with the same numeric quantity as this instance, but the opposite sign.
         /// </returns>
-        /// <param name="AngularVelocity">A <see cref="T:Gu.Units.AngularVelocity"/></param>
-        public static AngularVelocity operator -(AngularVelocity AngularVelocity)
+        /// <param name="AngularSpeed">A <see cref="T:Gu.Units.AngularSpeed"/></param>
+        public static AngularSpeed operator -(AngularSpeed AngularSpeed)
         {
-            return new AngularVelocity(-1 * AngularVelocity.RadiansPerSecond);
+            return new AngularSpeed(-1 * AngularSpeed.RadiansPerSecond);
         }
 
         /// <summary>
-        /// Returns the specified instance of <see cref="T:Gu.Units.AngularVelocity"/>.
+        /// Returns the specified instance of <see cref="T:Gu.Units.AngularSpeed"/>.
         /// </summary>
         /// <returns>
-        /// Returns <paramref name="AngularVelocity"/>.
+        /// Returns <paramref name="AngularSpeed"/>.
         /// </returns>
-        /// <param name="AngularVelocity">A <see cref="T:Gu.Units.AngularVelocity"/></param>
-        public static AngularVelocity operator +(AngularVelocity AngularVelocity)
+        /// <param name="AngularSpeed">A <see cref="T:Gu.Units.AngularSpeed"/></param>
+        public static AngularSpeed operator +(AngularSpeed AngularSpeed)
         {
-            return AngularVelocity;
+            return AngularSpeed;
         }
 
         public override string ToString()
@@ -263,17 +273,17 @@ public string ToString(IFormatProvider provider)
 
         public string ToString(string format, IFormatProvider formatProvider)
         {
-            return this.ToString(format, formatProvider, AngularVelocityUnit.RadiansPerSecond);
+            return this.ToString(format, formatProvider, AngularSpeedUnit.RadiansPerSecond);
         }
 
-        public string ToString(string format, IFormatProvider formatProvider, AngularVelocityUnit unit)
+        public string ToString(string format, IFormatProvider formatProvider, AngularSpeedUnit unit)
         {
             var quantity = unit.FromSiUnit(this.RadiansPerSecond);
             return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
         }
 
         /// <summary>
-        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.AngularVelocity"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.AngularVelocity"/> object.
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.AngularSpeed"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.AngularSpeed"/> object.
         /// </summary>
         /// <returns>
         /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
@@ -295,33 +305,33 @@ public string ToString(string format, IFormatProvider formatProvider, AngularVel
         ///                     This instance is larger than <paramref name="quantity"/>.
         /// 
         /// </returns>
-        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.AngularVelocity"/> object to compare to this instance.</param>
-        public int CompareTo(AngularVelocity quantity)
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.AngularSpeed"/> object to compare to this instance.</param>
+        public int CompareTo(AngularSpeed quantity)
         {
             return this.RadiansPerSecond.CompareTo(quantity.RadiansPerSecond);
         }
 
         /// <summary>
-        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.AngularVelocity"/> object.
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.AngularSpeed"/> object.
         /// </summary>
         /// <returns>
-        /// true if <paramref name="other"/> represents the same AngularVelocity as this instance; otherwise, false.
+        /// true if <paramref name="other"/> represents the same AngularSpeed as this instance; otherwise, false.
         /// </returns>
-        /// <param name="other">An <see cref="T:Gu.Units.AngularVelocity"/> object to compare with this instance.</param>
-        public bool Equals(AngularVelocity other)
+        /// <param name="other">An <see cref="T:Gu.Units.AngularSpeed"/> object to compare with this instance.</param>
+        public bool Equals(AngularSpeed other)
         {
             return this.RadiansPerSecond.Equals(other.RadiansPerSecond);
         }
 
         /// <summary>
-        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.AngularVelocity"/> object within the given tolerance.
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.AngularSpeed"/> object within the given tolerance.
         /// </summary>
         /// <returns>
-        /// true if <paramref name="other"/> represents the same AngularVelocity as this instance; otherwise, false.
+        /// true if <paramref name="other"/> represents the same AngularSpeed as this instance; otherwise, false.
         /// </returns>
-        /// <param name="other">An <see cref="T:Gu.Units.AngularVelocity"/> object to compare with this instance.</param>
+        /// <param name="other">An <see cref="T:Gu.Units.AngularSpeed"/> object to compare with this instance.</param>
         /// <param name="tolerance">The maximum difference for being considered equal</param>
-        public bool Equals(AngularVelocity other, double tolerance)
+        public bool Equals(AngularSpeed other, double tolerance)
         {
             return Math.Abs(this.RadiansPerSecond - other.RadiansPerSecond) < tolerance;
         }
@@ -333,7 +343,7 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return obj is AngularVelocity && this.Equals((AngularVelocity)obj);
+            return obj is AngularSpeed && this.Equals((AngularSpeed)obj);
         }
 
         public override int GetHashCode()
diff --git a/Gu.Units/AngularVelocityUnit.generated.cs b/Gu.Units/AngularSpeedUnit.generated.cs
similarity index 78%
rename from Gu.Units/AngularVelocityUnit.generated.cs
rename to Gu.Units/AngularSpeedUnit.generated.cs
index 0db4ce27..401864a5 100644
--- a/Gu.Units/AngularVelocityUnit.generated.cs
+++ b/Gu.Units/AngularSpeedUnit.generated.cs
@@ -2,22 +2,22 @@
 {
     using System;
     /// <summary>
-    /// A type for the unit <see cref="T:Gu.Units.AngularVelocityUnit"/>.
+    /// A type for the unit <see cref="T:Gu.Units.AngularSpeedUnit"/>.
     /// Contains conversion logic.
     /// </summary>
     [Serializable]
-    public struct AngularVelocityUnit : IUnit
+    public struct AngularSpeedUnit : IUnit
     {
         /// <summary>
         /// The <see cref="T:Gu.Units.RadiansPerSecond"/> unit
         /// Contains coonversion logic to from and formatting.
         /// </summary>
-        public static readonly AngularVelocityUnit RadiansPerSecond = new AngularVelocityUnit(1.0, "rad/s");
+        public static readonly AngularSpeedUnit RadiansPerSecond = new AngularSpeedUnit(1.0, "rad/s");
 
         private readonly double _conversionFactor;
         private readonly string _symbol;
 
-        public AngularVelocityUnit(double conversionFactor, string symbol)
+        public AngularSpeedUnit(double conversionFactor, string symbol)
         {
             _conversionFactor = conversionFactor;
             _symbol = symbol;
@@ -34,9 +34,9 @@ public string Symbol
             }
         }
 
-        public static AngularVelocity operator *(double left, AngularVelocityUnit right)
+        public static AngularSpeed operator *(double left, AngularSpeedUnit right)
         {
-            return AngularVelocity.From(left, right);
+            return AngularSpeed.From(left, right);
         }
 
         /// <summary>
diff --git a/Gu.Units/Area.generated.cs b/Gu.Units/Area.generated.cs
index 20718a1d..c720f736 100644
--- a/Gu.Units/Area.generated.cs
+++ b/Gu.Units/Area.generated.cs
@@ -165,6 +165,21 @@ public static Area FromSquareKilometres(double squareKilometres)
             return From(squareKilometres, AreaUnit.SquareKilometres);
         }
 
+        public static Length operator /(Area left, Length right)
+        {
+            return Length.FromMetres(left.SquareMetres / right.Metres);
+        }
+
+        public static Volume operator *(Area left, Length right)
+        {
+            return Volume.FromCubicMetres(left.SquareMetres * right.Metres);
+        }
+
+        public static VolumetricFlow operator *(Area left, Speed right)
+        {
+            return VolumetricFlow.FromCubicMetresPerSecond(left.SquareMetres * right.MetresPerSecond);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Area"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Current.generated.cs b/Gu.Units/Current.generated.cs
new file mode 100644
index 00000000..5220f76b
--- /dev/null
+++ b/Gu.Units/Current.generated.cs
@@ -0,0 +1,458 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.Current"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct Current : IComparable<Current>, IEquatable<Current>, IFormattable, IXmlSerializable, IQuantity<CurrentUnit, I1>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.Amperes"/>.
+        /// </summary>
+        public readonly double Amperes;
+
+        private Current(double amperes)
+        {
+            Amperes = amperes;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.Amperes"/>.</param>
+        public Current(double value, CurrentUnit unit)
+        {
+            Amperes = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in Amperes
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return Amperes;
+            }
+        }
+
+        /// <summary>
+        /// The quantity in milliamperes
+        /// </summary>
+        public double Milliamperes
+        {
+            get
+            {
+                return CurrentUnit.Milliamperes.FromSiUnit(Amperes);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in kiloamperes
+        /// </summary>
+        public double Kiloamperes
+        {
+            get
+            {
+                return CurrentUnit.Kiloamperes.FromSiUnit(Amperes);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in megaamperes
+        /// </summary>
+        public double Megaamperes
+        {
+            get
+            {
+                return CurrentUnit.Megaamperes.FromSiUnit(Amperes);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in microamperes
+        /// </summary>
+        public double Microamperes
+        {
+            get
+            {
+                return CurrentUnit.Microamperes.FromSiUnit(Amperes);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.Current"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.Current"/></param>
+        /// <returns></returns>
+        public static Current Parse(string s)
+        {
+            return Parser.Parse<CurrentUnit, Current>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.Current"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.Current"/></returns>
+        public static Current ReadFrom(XmlReader reader)
+        {
+            var v = new Current();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static Current From(double value, CurrentUnit unit)
+        {
+            return new Current(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="amperes">The value in <see cref="T:Gu.Units.Amperes"/></param>
+        public static Current FromAmperes(double amperes)
+        {
+            return new Current(amperes);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="milliamperes">The value in mA</param>
+        public static Current FromMilliamperes(double milliamperes)
+        {
+            return From(milliamperes, CurrentUnit.Milliamperes);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="kiloamperes">The value in kA</param>
+        public static Current FromKiloamperes(double kiloamperes)
+        {
+            return From(kiloamperes, CurrentUnit.Kiloamperes);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="megaamperes">The value in MA</param>
+        public static Current FromMegaamperes(double megaamperes)
+        {
+            return From(megaamperes, CurrentUnit.Megaamperes);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <param name="microamperes">The value in µA</param>
+        public static Current FromMicroamperes(double microamperes)
+        {
+            return From(microamperes, CurrentUnit.Microamperes);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Current"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Current"/>.</param>
+        public static bool operator ==(Current left, Current right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Current"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Current"/>.</param>
+        public static bool operator !=(Current left, Current right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Current"/> is less than another specified <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Current"/>.</param>
+        public static bool operator <(Current left, Current right)
+        {
+            return left.Amperes < right.Amperes;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Current"/> is greater than another specified <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Current"/>.</param>
+        public static bool operator >(Current left, Current right)
+        {
+            return left.Amperes > right.Amperes;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Current"/> is less than or equal to another specified <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Current"/>.</param>
+        public static bool operator <=(Current left, Current right)
+        {
+            return left.Amperes <= right.Amperes;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Current"/> is greater than or equal to another specified <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Current"/>.</param>
+        public static bool operator >=(Current left, Current right)
+        {
+            return left.Amperes >= right.Amperes;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Current"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.Current"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Current"/> with <paramref name="left"/> and returns the result.</returns>
+        public static Current operator *(double left, Current right)
+        {
+            return new Current(left * right.Amperes);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Current"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Current"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Current"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Current operator *(Current left, double right)
+        {
+            return new Current(left.Amperes * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.Current"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Current"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.Current"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Current operator /(Current left, double right)
+        {
+            return new Current(left.Amperes / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.Current"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Current"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Current"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static Current operator +(Current left, Current right)
+        {
+            return new Current(left.Amperes + right.Amperes);
+        }
+
+        /// <summary>
+        /// Subtracts an Current from another Current and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Current"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Current"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Current"/> (the subtrahend).</param>
+        public static Current operator -(Current left, Current right)
+        {
+            return new Current(left.Amperes - right.Amperes);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.Current"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Current"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="Current">A <see cref="T:Gu.Units.Current"/></param>
+        public static Current operator -(Current Current)
+        {
+            return new Current(-1 * Current.Amperes);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.Current"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="Current"/>.
+        /// </returns>
+        /// <param name="Current">A <see cref="T:Gu.Units.Current"/></param>
+        public static Current operator +(Current Current)
+        {
+            return Current;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, CurrentUnit.Amperes);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, CurrentUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.Amperes);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.Current"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.Current"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.Current"/> object to compare to this instance.</param>
+        public int CompareTo(Current quantity)
+        {
+            return this.Amperes.CompareTo(quantity.Amperes);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Current"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Current as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Current"/> object to compare with this instance.</param>
+        public bool Equals(Current other)
+        {
+            return this.Amperes.Equals(other.Amperes);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Current"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Current as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Current"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(Current other, double tolerance)
+        {
+            return Math.Abs(this.Amperes - other.Amperes) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is Current && this.Equals((Current)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.Amperes.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.Amperes, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.Amperes);
+        }
+    }
+}
diff --git a/Gu.Units/CurrentUnit.generated.cs b/Gu.Units/CurrentUnit.generated.cs
new file mode 100644
index 00000000..b1040bb7
--- /dev/null
+++ b/Gu.Units/CurrentUnit.generated.cs
@@ -0,0 +1,116 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.CurrentUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct CurrentUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Amperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit Amperes = new CurrentUnit(1.0, "A");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Amperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit A = Amperes;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Milliamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit Milliamperes = new CurrentUnit(0.001, "mA");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Milliamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit mA = Milliamperes;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Kiloamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit Kiloamperes = new CurrentUnit(1000, "kA");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Kiloamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit kA = Kiloamperes;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Megaamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit Megaamperes = new CurrentUnit(1000000, "MA");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Megaamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit MA = Megaamperes;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Microamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit Microamperes = new CurrentUnit(1E-06, "µA");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Microamperes"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly CurrentUnit µA = Microamperes;
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public CurrentUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.Amperes"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static Current operator *(double left, CurrentUnit right)
+        {
+            return Current.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.Amperes"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from Amperes.
+        /// </summary>
+        /// <param name="value">The value in Amperes</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), Amperes.Symbol);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gu.Units/Density.generated.cs b/Gu.Units/Density.generated.cs
index 1792a296..855f6ab1 100644
--- a/Gu.Units/Density.generated.cs
+++ b/Gu.Units/Density.generated.cs
@@ -125,6 +125,11 @@ public static Density FromGramsPerCubicCentimetre(double gramsPerCubicCentimetre
             return From(gramsPerCubicCentimetre, DensityUnit.GramsPerCubicCentimetre);
         }
 
+        public static Mass operator *(Density left, Volume right)
+        {
+            return Mass.FromKilograms(left.KilogramsPerCubicMetre * right.CubicMetres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Density"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Energy.generated.cs b/Gu.Units/Energy.generated.cs
index 50b82105..cf46fdf8 100644
--- a/Gu.Units/Energy.generated.cs
+++ b/Gu.Units/Energy.generated.cs
@@ -225,6 +225,36 @@ public static Energy FromKilowattHours(double kilowattHours)
             return From(kilowattHours, EnergyUnit.KilowattHours);
         }
 
+        public static Length operator /(Energy left, Force right)
+        {
+            return Length.FromMetres(left.Joules / right.Newtons);
+        }
+
+        public static Force operator /(Energy left, Length right)
+        {
+            return Force.FromNewtons(left.Joules / right.Metres);
+        }
+
+        public static Pressure operator /(Energy left, Volume right)
+        {
+            return Pressure.FromPascals(left.Joules / right.CubicMetres);
+        }
+
+        public static Power operator /(Energy left, Time right)
+        {
+            return Power.FromWatts(left.Joules / right.Seconds);
+        }
+
+        public static Torque operator /(Energy left, Angle right)
+        {
+            return Torque.FromNewtonMetres(left.Joules / right.Radians);
+        }
+
+        public static Stiffness operator /(Energy left, Area right)
+        {
+            return Stiffness.FromNewtonsPerMetre(left.Joules / right.SquareMetres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Energy"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Force.generated.cs b/Gu.Units/Force.generated.cs
index b6a44e48..b732c9a9 100644
--- a/Gu.Units/Force.generated.cs
+++ b/Gu.Units/Force.generated.cs
@@ -205,6 +205,36 @@ public static Force FromGiganewtons(double giganewtons)
             return From(giganewtons, ForceUnit.Giganewtons);
         }
 
+        public static Mass operator /(Force left, Acceleration right)
+        {
+            return Mass.FromKilograms(left.Newtons / right.MetresPerSecondSquared);
+        }
+
+        public static Pressure operator /(Force left, Area right)
+        {
+            return Pressure.FromPascals(left.Newtons / right.SquareMetres);
+        }
+
+        public static Energy operator *(Force left, Length right)
+        {
+            return Energy.FromJoules(left.Newtons * right.Metres);
+        }
+
+        public static Power operator *(Force left, Speed right)
+        {
+            return Power.FromWatts(left.Newtons * right.MetresPerSecond);
+        }
+
+        public static Acceleration operator /(Force left, Mass right)
+        {
+            return Acceleration.FromMetresPerSecondSquared(left.Newtons / right.Kilograms);
+        }
+
+        public static Stiffness operator /(Force left, Length right)
+        {
+            return Stiffness.FromNewtonsPerMetre(left.Newtons / right.Metres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Force"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Frequency.generated.cs b/Gu.Units/Frequency.generated.cs
index a3894622..173f1dcf 100644
--- a/Gu.Units/Frequency.generated.cs
+++ b/Gu.Units/Frequency.generated.cs
@@ -165,6 +165,31 @@ public static Frequency FromGigahertz(double gigahertz)
             return From(gigahertz, FrequencyUnit.Gigahertz);
         }
 
+        public static Power operator *(Frequency left, Energy right)
+        {
+            return Power.FromWatts(left.Hertz * right.Joules);
+        }
+
+        public static Speed operator *(Frequency left, Length right)
+        {
+            return Speed.FromMetresPerSecond(left.Hertz * right.Metres);
+        }
+
+        public static AngularSpeed operator *(Frequency left, Angle right)
+        {
+            return AngularSpeed.FromRadiansPerSecond(left.Hertz * right.Radians);
+        }
+
+        public static Acceleration operator *(Frequency left, Speed right)
+        {
+            return Acceleration.FromMetresPerSecondSquared(left.Hertz * right.MetresPerSecond);
+        }
+
+        public static VolumetricFlow operator *(Frequency left, Volume right)
+        {
+            return VolumetricFlow.FromCubicMetresPerSecond(left.Hertz * right.CubicMetres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Frequency"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Gu.Units.csproj b/Gu.Units/Gu.Units.csproj
index 69e5478b..f63f71d9 100644
--- a/Gu.Units/Gu.Units.csproj
+++ b/Gu.Units/Gu.Units.csproj
@@ -45,16 +45,22 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Acceleration.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="AccelerationUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="Angle.generated.cs">
       <DependentUpon>QuantityGenerator.txt4</DependentUpon>
     </Compile>
     <Compile Include="AngleUnit.generated.cs">
       <DependentUpon>UnitGenerator.txt4</DependentUpon>
     </Compile>
-    <Compile Include="AngularVelocity.generated.cs">
+    <Compile Include="AngularSpeed.generated.cs">
       <DependentUpon>QuantityGenerator.txt4</DependentUpon>
     </Compile>
-    <Compile Include="AngularVelocityUnit.generated.cs">
+    <Compile Include="AngularSpeedUnit.generated.cs">
       <DependentUpon>UnitGenerator.txt4</DependentUpon>
     </Compile>
     <Compile Include="Area.generated.cs">
@@ -63,6 +69,12 @@
     <Compile Include="AreaUnit.generated.cs">
       <DependentUpon>UnitGenerator.txt4</DependentUpon>
     </Compile>
+    <Compile Include="Current.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="CurrentUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="Density.generated.cs">
       <DependentUpon>QuantityGenerator.txt4</DependentUpon>
     </Compile>
@@ -120,12 +132,24 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Interfaces\IUnit.cs" />
     <Compile Include="Interfaces\IQuantity.cs" />
+    <Compile Include="Resistance.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="ResistanceUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="Speed.generated.cs">
       <DependentUpon>QuantityGenerator.txt4</DependentUpon>
     </Compile>
     <Compile Include="SpeedUnit.generated.cs">
       <DependentUpon>UnitGenerator.txt4</DependentUpon>
     </Compile>
+    <Compile Include="Stiffness.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="StiffnessUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="Temperature.generated.cs">
       <DependentUpon>QuantityGenerator.txt4</DependentUpon>
     </Compile>
@@ -138,13 +162,31 @@
     <Compile Include="TimeUnit.generated.cs">
       <DependentUpon>UnitGenerator.txt4</DependentUpon>
     </Compile>
+    <Compile Include="Torque.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="TorqueUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="Utils\Arithmetics.cs" />
     <Compile Include="Utils\UnitConverter.cs" />
     <Compile Include="Utils\Parser.cs" />
     <Compile Include="Utils\XmlExt.cs" />
+    <Compile Include="Voltage.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="VoltageUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="Volume.generated.cs">
       <DependentUpon>QuantityGenerator.txt4</DependentUpon>
     </Compile>
+    <Compile Include="VolumetricFlow.generated.cs">
+      <DependentUpon>QuantityGenerator.txt4</DependentUpon>
+    </Compile>
+    <Compile Include="VolumetricFlowUnit.generated.cs">
+      <DependentUpon>UnitGenerator.txt4</DependentUpon>
+    </Compile>
     <Compile Include="VolumeUnit.generated.cs">
       <DependentUpon>UnitGenerator.txt4</DependentUpon>
     </Compile>
diff --git a/Gu.Units/Interfaces/IQuantity.cs b/Gu.Units/Interfaces/IQuantity.cs
index 3298f4e9..57cecf87 100644
--- a/Gu.Units/Interfaces/IQuantity.cs
+++ b/Gu.Units/Interfaces/IQuantity.cs
@@ -45,6 +45,19 @@ public interface IQuantity<TUnit1, TPower1, TUnit2, TPower2, TUnit3, TPower3> :
         where TPower3 : IPower
     {
     }
+
+    public interface IQuantity<TUnit1, TPower1, TUnit2, TPower2, TUnit3, TPower3, TUnit4, TPower4> : IQuantity
+        where TUnit1 : IUnit
+        where TPower1 : IPower
+        where TUnit2 : IUnit
+        where TPower2 : IPower
+        where TUnit3 : IUnit
+        where TPower3 : IPower
+        where TUnit4 : IUnit
+        where TPower4 : IPower
+    {
+    }
+
     public interface IPower
     {
     }
diff --git a/Gu.Units/Length.generated.cs b/Gu.Units/Length.generated.cs
index fb3dffc9..dafb7d5c 100644
--- a/Gu.Units/Length.generated.cs
+++ b/Gu.Units/Length.generated.cs
@@ -205,6 +205,31 @@ public static Length FromKilometres(double kilometres)
             return From(kilometres, LengthUnit.Kilometres);
         }
 
+        public static Time operator /(Length left, Speed right)
+        {
+            return Time.FromSeconds(left.Metres / right.MetresPerSecond);
+        }
+
+        public static Area operator *(Length left, Length right)
+        {
+            return Area.FromSquareMetres(left.Metres * right.Metres);
+        }
+
+        public static Volume operator *(Length left, Area right)
+        {
+            return Volume.FromCubicMetres(left.Metres * right.SquareMetres);
+        }
+
+        public static Energy operator *(Length left, Force right)
+        {
+            return Energy.FromJoules(left.Metres * right.Newtons);
+        }
+
+        public static Speed operator /(Length left, Time right)
+        {
+            return Speed.FromMetresPerSecond(left.Metres / right.Seconds);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Length"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Mass.generated.cs b/Gu.Units/Mass.generated.cs
index 59187d83..494e29c9 100644
--- a/Gu.Units/Mass.generated.cs
+++ b/Gu.Units/Mass.generated.cs
@@ -145,6 +145,21 @@ public static Mass FromMicrograms(double micrograms)
             return From(micrograms, MassUnit.Micrograms);
         }
 
+        public static Volume operator /(Mass left, Density right)
+        {
+            return Volume.FromCubicMetres(left.Kilograms / right.KilogramsPerCubicMetre);
+        }
+
+        public static Force operator *(Mass left, Acceleration right)
+        {
+            return Force.FromNewtons(left.Kilograms * right.MetresPerSecondSquared);
+        }
+
+        public static Density operator /(Mass left, Volume right)
+        {
+            return Density.FromKilogramsPerCubicMetre(left.Kilograms / right.CubicMetres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Mass"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Power.generated.cs b/Gu.Units/Power.generated.cs
index 365ff047..45708290 100644
--- a/Gu.Units/Power.generated.cs
+++ b/Gu.Units/Power.generated.cs
@@ -205,6 +205,36 @@ public static Power FromGigawatts(double gigawatts)
             return From(gigawatts, PowerUnit.Gigawatts);
         }
 
+        public static Force operator /(Power left, Speed right)
+        {
+            return Force.FromNewtons(left.Watts / right.MetresPerSecond);
+        }
+
+        public static Energy operator *(Power left, Time right)
+        {
+            return Energy.FromJoules(left.Watts * right.Seconds);
+        }
+
+        public static Speed operator /(Power left, Force right)
+        {
+            return Speed.FromMetresPerSecond(left.Watts / right.Newtons);
+        }
+
+        public static Frequency operator /(Power left, Energy right)
+        {
+            return Frequency.FromHertz(left.Watts / right.Joules);
+        }
+
+        public static Torque operator /(Power left, AngularSpeed right)
+        {
+            return Torque.FromNewtonMetres(left.Watts / right.RadiansPerSecond);
+        }
+
+        public static Voltage operator /(Power left, Current right)
+        {
+            return Voltage.FromVolts(left.Watts / right.Amperes);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Power"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Pressure.generated.cs b/Gu.Units/Pressure.generated.cs
index 6b5d2a83..60801f33 100644
--- a/Gu.Units/Pressure.generated.cs
+++ b/Gu.Units/Pressure.generated.cs
@@ -205,6 +205,21 @@ public static Pressure FromGigapascals(double gigapascals)
             return From(gigapascals, PressureUnit.Gigapascals);
         }
 
+        public static Force operator *(Pressure left, Area right)
+        {
+            return Force.FromNewtons(left.Pascals * right.SquareMetres);
+        }
+
+        public static Energy operator *(Pressure left, Volume right)
+        {
+            return Energy.FromJoules(left.Pascals * right.CubicMetres);
+        }
+
+        public static Stiffness operator *(Pressure left, Length right)
+        {
+            return Stiffness.FromNewtonsPerMetre(left.Pascals * right.Metres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Pressure"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Resistance.generated.cs b/Gu.Units/Resistance.generated.cs
new file mode 100644
index 00000000..654ae0ff
--- /dev/null
+++ b/Gu.Units/Resistance.generated.cs
@@ -0,0 +1,463 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.Resistance"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct Resistance : IComparable<Resistance>, IEquatable<Resistance>, IFormattable, IXmlSerializable, IQuantity<MassUnit, I1, LengthUnit, I2, TimeUnit, INeg3, CurrentUnit, INeg2>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.Ohm"/>.
+        /// </summary>
+        public readonly double Ohm;
+
+        private Resistance(double ohm)
+        {
+            Ohm = ohm;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.Ohm"/>.</param>
+        public Resistance(double value, ResistanceUnit unit)
+        {
+            Ohm = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in Ohm
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return Ohm;
+            }
+        }
+
+        /// <summary>
+        /// The quantity in microohm
+        /// </summary>
+        public double Microohm
+        {
+            get
+            {
+                return ResistanceUnit.Microohm.FromSiUnit(Ohm);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in milliohm
+        /// </summary>
+        public double Milliohm
+        {
+            get
+            {
+                return ResistanceUnit.Milliohm.FromSiUnit(Ohm);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in kiloohm
+        /// </summary>
+        public double Kiloohm
+        {
+            get
+            {
+                return ResistanceUnit.Kiloohm.FromSiUnit(Ohm);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in megaohm
+        /// </summary>
+        public double Megaohm
+        {
+            get
+            {
+                return ResistanceUnit.Megaohm.FromSiUnit(Ohm);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.Resistance"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.Resistance"/></param>
+        /// <returns></returns>
+        public static Resistance Parse(string s)
+        {
+            return Parser.Parse<ResistanceUnit, Resistance>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.Resistance"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.Resistance"/></returns>
+        public static Resistance ReadFrom(XmlReader reader)
+        {
+            var v = new Resistance();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static Resistance From(double value, ResistanceUnit unit)
+        {
+            return new Resistance(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="ohm">The value in <see cref="T:Gu.Units.Ohm"/></param>
+        public static Resistance FromOhm(double ohm)
+        {
+            return new Resistance(ohm);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="microohm">The value in µΩ</param>
+        public static Resistance FromMicroohm(double microohm)
+        {
+            return From(microohm, ResistanceUnit.Microohm);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="milliohm">The value in mΩ</param>
+        public static Resistance FromMilliohm(double milliohm)
+        {
+            return From(milliohm, ResistanceUnit.Milliohm);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="kiloohm">The value in kΩ</param>
+        public static Resistance FromKiloohm(double kiloohm)
+        {
+            return From(kiloohm, ResistanceUnit.Kiloohm);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <param name="megaohm">The value in MΩ</param>
+        public static Resistance FromMegaohm(double megaohm)
+        {
+            return From(megaohm, ResistanceUnit.Megaohm);
+        }
+
+        public static Voltage operator *(Resistance left, Current right)
+        {
+            return Voltage.FromVolts(left.Ohm * right.Amperes);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Resistance"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Resistance"/>.</param>
+        public static bool operator ==(Resistance left, Resistance right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Resistance"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Resistance"/>.</param>
+        public static bool operator !=(Resistance left, Resistance right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Resistance"/> is less than another specified <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        public static bool operator <(Resistance left, Resistance right)
+        {
+            return left.Ohm < right.Ohm;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Resistance"/> is greater than another specified <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        public static bool operator >(Resistance left, Resistance right)
+        {
+            return left.Ohm > right.Ohm;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Resistance"/> is less than or equal to another specified <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        public static bool operator <=(Resistance left, Resistance right)
+        {
+            return left.Ohm <= right.Ohm;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Resistance"/> is greater than or equal to another specified <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Resistance"/>.</param>
+        public static bool operator >=(Resistance left, Resistance right)
+        {
+            return left.Ohm >= right.Ohm;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Resistance"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.Resistance"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Resistance"/> with <paramref name="left"/> and returns the result.</returns>
+        public static Resistance operator *(double left, Resistance right)
+        {
+            return new Resistance(left * right.Ohm);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Resistance"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Resistance"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Resistance"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Resistance operator *(Resistance left, double right)
+        {
+            return new Resistance(left.Ohm * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.Resistance"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Resistance"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.Resistance"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Resistance operator /(Resistance left, double right)
+        {
+            return new Resistance(left.Ohm / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.Resistance"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Resistance"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Resistance"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static Resistance operator +(Resistance left, Resistance right)
+        {
+            return new Resistance(left.Ohm + right.Ohm);
+        }
+
+        /// <summary>
+        /// Subtracts an Resistance from another Resistance and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Resistance"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Resistance"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Resistance"/> (the subtrahend).</param>
+        public static Resistance operator -(Resistance left, Resistance right)
+        {
+            return new Resistance(left.Ohm - right.Ohm);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.Resistance"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Resistance"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="Resistance">A <see cref="T:Gu.Units.Resistance"/></param>
+        public static Resistance operator -(Resistance Resistance)
+        {
+            return new Resistance(-1 * Resistance.Ohm);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.Resistance"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="Resistance"/>.
+        /// </returns>
+        /// <param name="Resistance">A <see cref="T:Gu.Units.Resistance"/></param>
+        public static Resistance operator +(Resistance Resistance)
+        {
+            return Resistance;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, ResistanceUnit.Ohm);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, ResistanceUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.Ohm);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.Resistance"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.Resistance"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.Resistance"/> object to compare to this instance.</param>
+        public int CompareTo(Resistance quantity)
+        {
+            return this.Ohm.CompareTo(quantity.Ohm);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Resistance"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Resistance as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Resistance"/> object to compare with this instance.</param>
+        public bool Equals(Resistance other)
+        {
+            return this.Ohm.Equals(other.Ohm);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Resistance"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Resistance as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Resistance"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(Resistance other, double tolerance)
+        {
+            return Math.Abs(this.Ohm - other.Ohm) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is Resistance && this.Equals((Resistance)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.Ohm.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.Ohm, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.Ohm);
+        }
+    }
+}
diff --git a/Gu.Units/ResistanceUnit.generated.cs b/Gu.Units/ResistanceUnit.generated.cs
new file mode 100644
index 00000000..681d50ab
--- /dev/null
+++ b/Gu.Units/ResistanceUnit.generated.cs
@@ -0,0 +1,116 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.ResistanceUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct ResistanceUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Ohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit Ohm = new ResistanceUnit(1.0, "Ω");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Ohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit Ω = Ohm;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Microohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit Microohm = new ResistanceUnit(1E-06, "µΩ");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Microohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit µΩ = Microohm;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Milliohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit Milliohm = new ResistanceUnit(0.001, "mΩ");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Milliohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit mΩ = Milliohm;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Kiloohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit Kiloohm = new ResistanceUnit(1000, "kΩ");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Kiloohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit kΩ = Kiloohm;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Megaohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit Megaohm = new ResistanceUnit(1000000, "MΩ");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Megaohm"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly ResistanceUnit MΩ = Megaohm;
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public ResistanceUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.Ohm"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static Resistance operator *(double left, ResistanceUnit right)
+        {
+            return Resistance.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.Ohm"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from Ohm.
+        /// </summary>
+        /// <param name="value">The value in Ohm</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), Ohm.Symbol);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gu.Units/Speed.generated.cs b/Gu.Units/Speed.generated.cs
index a2a3a25b..792818c6 100644
--- a/Gu.Units/Speed.generated.cs
+++ b/Gu.Units/Speed.generated.cs
@@ -265,6 +265,36 @@ public static Speed FromMillimetresPerMinute(double millimetresPerMinute)
             return From(millimetresPerMinute, SpeedUnit.MillimetresPerMinute);
         }
 
+        public static Length operator *(Speed left, Time right)
+        {
+            return Length.FromMetres(left.MetresPerSecond * right.Seconds);
+        }
+
+        public static Time operator /(Speed left, Acceleration right)
+        {
+            return Time.FromSeconds(left.MetresPerSecond / right.MetresPerSecondSquared);
+        }
+
+        public static Power operator *(Speed left, Force right)
+        {
+            return Power.FromWatts(left.MetresPerSecond * right.Newtons);
+        }
+
+        public static Frequency operator /(Speed left, Length right)
+        {
+            return Frequency.FromHertz(left.MetresPerSecond / right.Metres);
+        }
+
+        public static Acceleration operator /(Speed left, Time right)
+        {
+            return Acceleration.FromMetresPerSecondSquared(left.MetresPerSecond / right.Seconds);
+        }
+
+        public static VolumetricFlow operator *(Speed left, Area right)
+        {
+            return VolumetricFlow.FromCubicMetresPerSecond(left.MetresPerSecond * right.SquareMetres);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Speed"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Stiffness.generated.cs b/Gu.Units/Stiffness.generated.cs
new file mode 100644
index 00000000..244c2878
--- /dev/null
+++ b/Gu.Units/Stiffness.generated.cs
@@ -0,0 +1,393 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.Stiffness"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct Stiffness : IComparable<Stiffness>, IEquatable<Stiffness>, IFormattable, IXmlSerializable, IQuantity<MassUnit, I1, TimeUnit, INeg2>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.NewtonsPerMetre"/>.
+        /// </summary>
+        public readonly double NewtonsPerMetre;
+
+        private Stiffness(double newtonsPerMetre)
+        {
+            NewtonsPerMetre = newtonsPerMetre;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.NewtonsPerMetre"/>.</param>
+        public Stiffness(double value, StiffnessUnit unit)
+        {
+            NewtonsPerMetre = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in NewtonsPerMetre
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return NewtonsPerMetre;
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.Stiffness"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.Stiffness"/></param>
+        /// <returns></returns>
+        public static Stiffness Parse(string s)
+        {
+            return Parser.Parse<StiffnessUnit, Stiffness>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.Stiffness"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.Stiffness"/></returns>
+        public static Stiffness ReadFrom(XmlReader reader)
+        {
+            var v = new Stiffness();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static Stiffness From(double value, StiffnessUnit unit)
+        {
+            return new Stiffness(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <param name="newtonsPerMetre">The value in <see cref="T:Gu.Units.NewtonsPerMetre"/></param>
+        public static Stiffness FromNewtonsPerMetre(double newtonsPerMetre)
+        {
+            return new Stiffness(newtonsPerMetre);
+        }
+
+        public static Force operator *(Stiffness left, Length right)
+        {
+            return Force.FromNewtons(left.NewtonsPerMetre * right.Metres);
+        }
+
+        public static Pressure operator /(Stiffness left, Length right)
+        {
+            return Pressure.FromPascals(left.NewtonsPerMetre / right.Metres);
+        }
+
+        public static Energy operator *(Stiffness left, Area right)
+        {
+            return Energy.FromJoules(left.NewtonsPerMetre * right.SquareMetres);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Stiffness"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Stiffness"/>.</param>
+        public static bool operator ==(Stiffness left, Stiffness right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Stiffness"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Stiffness"/>.</param>
+        public static bool operator !=(Stiffness left, Stiffness right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Stiffness"/> is less than another specified <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        public static bool operator <(Stiffness left, Stiffness right)
+        {
+            return left.NewtonsPerMetre < right.NewtonsPerMetre;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Stiffness"/> is greater than another specified <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        public static bool operator >(Stiffness left, Stiffness right)
+        {
+            return left.NewtonsPerMetre > right.NewtonsPerMetre;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Stiffness"/> is less than or equal to another specified <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        public static bool operator <=(Stiffness left, Stiffness right)
+        {
+            return left.NewtonsPerMetre <= right.NewtonsPerMetre;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Stiffness"/> is greater than or equal to another specified <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Stiffness"/>.</param>
+        public static bool operator >=(Stiffness left, Stiffness right)
+        {
+            return left.NewtonsPerMetre >= right.NewtonsPerMetre;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Stiffness"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.Stiffness"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Stiffness"/> with <paramref name="left"/> and returns the result.</returns>
+        public static Stiffness operator *(double left, Stiffness right)
+        {
+            return new Stiffness(left * right.NewtonsPerMetre);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Stiffness"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Stiffness"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Stiffness"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Stiffness operator *(Stiffness left, double right)
+        {
+            return new Stiffness(left.NewtonsPerMetre * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.Stiffness"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Stiffness"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.Stiffness"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Stiffness operator /(Stiffness left, double right)
+        {
+            return new Stiffness(left.NewtonsPerMetre / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.Stiffness"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Stiffness"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Stiffness"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static Stiffness operator +(Stiffness left, Stiffness right)
+        {
+            return new Stiffness(left.NewtonsPerMetre + right.NewtonsPerMetre);
+        }
+
+        /// <summary>
+        /// Subtracts an Stiffness from another Stiffness and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Stiffness"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Stiffness"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Stiffness"/> (the subtrahend).</param>
+        public static Stiffness operator -(Stiffness left, Stiffness right)
+        {
+            return new Stiffness(left.NewtonsPerMetre - right.NewtonsPerMetre);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.Stiffness"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Stiffness"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="Stiffness">A <see cref="T:Gu.Units.Stiffness"/></param>
+        public static Stiffness operator -(Stiffness Stiffness)
+        {
+            return new Stiffness(-1 * Stiffness.NewtonsPerMetre);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.Stiffness"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="Stiffness"/>.
+        /// </returns>
+        /// <param name="Stiffness">A <see cref="T:Gu.Units.Stiffness"/></param>
+        public static Stiffness operator +(Stiffness Stiffness)
+        {
+            return Stiffness;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, StiffnessUnit.NewtonsPerMetre);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, StiffnessUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.NewtonsPerMetre);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.Stiffness"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.Stiffness"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.Stiffness"/> object to compare to this instance.</param>
+        public int CompareTo(Stiffness quantity)
+        {
+            return this.NewtonsPerMetre.CompareTo(quantity.NewtonsPerMetre);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Stiffness"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Stiffness as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Stiffness"/> object to compare with this instance.</param>
+        public bool Equals(Stiffness other)
+        {
+            return this.NewtonsPerMetre.Equals(other.NewtonsPerMetre);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Stiffness"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Stiffness as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Stiffness"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(Stiffness other, double tolerance)
+        {
+            return Math.Abs(this.NewtonsPerMetre - other.NewtonsPerMetre) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is Stiffness && this.Equals((Stiffness)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.NewtonsPerMetre.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.NewtonsPerMetre, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.NewtonsPerMetre);
+        }
+    }
+}
diff --git a/Gu.Units/StiffnessUnit.generated.cs b/Gu.Units/StiffnessUnit.generated.cs
new file mode 100644
index 00000000..9b282f8b
--- /dev/null
+++ b/Gu.Units/StiffnessUnit.generated.cs
@@ -0,0 +1,67 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.StiffnessUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct StiffnessUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.NewtonsPerMetre"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly StiffnessUnit NewtonsPerMetre = new StiffnessUnit(1.0, "N/m");
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public StiffnessUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.NewtonsPerMetre"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static Stiffness operator *(double left, StiffnessUnit right)
+        {
+            return Stiffness.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.NewtonsPerMetre"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from NewtonsPerMetre.
+        /// </summary>
+        /// <param name="value">The value in NewtonsPerMetre</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), NewtonsPerMetre.Symbol);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gu.Units/Time.generated.cs b/Gu.Units/Time.generated.cs
index d34d734a..059e061b 100644
--- a/Gu.Units/Time.generated.cs
+++ b/Gu.Units/Time.generated.cs
@@ -185,6 +185,21 @@ public static Time FromMinutes(double minutes)
             return From(minutes, TimeUnit.Minutes);
         }
 
+        public static Length operator *(Time left, Speed right)
+        {
+            return Length.FromMetres(left.Seconds * right.MetresPerSecond);
+        }
+
+        public static Angle operator *(Time left, AngularSpeed right)
+        {
+            return Angle.FromRadians(left.Seconds * right.RadiansPerSecond);
+        }
+
+        public static Speed operator *(Time left, Acceleration right)
+        {
+            return Speed.FromMetresPerSecond(left.Seconds * right.MetresPerSecondSquared);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Time"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/Torque.generated.cs b/Gu.Units/Torque.generated.cs
new file mode 100644
index 00000000..a6909ed2
--- /dev/null
+++ b/Gu.Units/Torque.generated.cs
@@ -0,0 +1,388 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.Torque"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct Torque : IComparable<Torque>, IEquatable<Torque>, IFormattable, IXmlSerializable, IQuantity<MassUnit, I1, LengthUnit, I2, TimeUnit, INeg2, AngleUnit, INeg1>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.NewtonMetres"/>.
+        /// </summary>
+        public readonly double NewtonMetres;
+
+        private Torque(double newtonMetres)
+        {
+            NewtonMetres = newtonMetres;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.NewtonMetres"/>.</param>
+        public Torque(double value, TorqueUnit unit)
+        {
+            NewtonMetres = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in NewtonMetres
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return NewtonMetres;
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.Torque"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.Torque"/></param>
+        /// <returns></returns>
+        public static Torque Parse(string s)
+        {
+            return Parser.Parse<TorqueUnit, Torque>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.Torque"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.Torque"/></returns>
+        public static Torque ReadFrom(XmlReader reader)
+        {
+            var v = new Torque();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static Torque From(double value, TorqueUnit unit)
+        {
+            return new Torque(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <param name="newtonMetres">The value in <see cref="T:Gu.Units.NewtonMetres"/></param>
+        public static Torque FromNewtonMetres(double newtonMetres)
+        {
+            return new Torque(newtonMetres);
+        }
+
+        public static Energy operator *(Torque left, Angle right)
+        {
+            return Energy.FromJoules(left.NewtonMetres * right.Radians);
+        }
+
+        public static Power operator *(Torque left, AngularSpeed right)
+        {
+            return Power.FromWatts(left.NewtonMetres * right.RadiansPerSecond);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Torque"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Torque"/>.</param>
+        public static bool operator ==(Torque left, Torque right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Torque"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Torque"/>.</param>
+        public static bool operator !=(Torque left, Torque right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Torque"/> is less than another specified <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Torque"/>.</param>
+        public static bool operator <(Torque left, Torque right)
+        {
+            return left.NewtonMetres < right.NewtonMetres;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Torque"/> is greater than another specified <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Torque"/>.</param>
+        public static bool operator >(Torque left, Torque right)
+        {
+            return left.NewtonMetres > right.NewtonMetres;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Torque"/> is less than or equal to another specified <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Torque"/>.</param>
+        public static bool operator <=(Torque left, Torque right)
+        {
+            return left.NewtonMetres <= right.NewtonMetres;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Torque"/> is greater than or equal to another specified <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Torque"/>.</param>
+        public static bool operator >=(Torque left, Torque right)
+        {
+            return left.NewtonMetres >= right.NewtonMetres;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Torque"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.Torque"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Torque"/> with <paramref name="left"/> and returns the result.</returns>
+        public static Torque operator *(double left, Torque right)
+        {
+            return new Torque(left * right.NewtonMetres);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Torque"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Torque"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Torque"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Torque operator *(Torque left, double right)
+        {
+            return new Torque(left.NewtonMetres * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.Torque"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Torque"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.Torque"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Torque operator /(Torque left, double right)
+        {
+            return new Torque(left.NewtonMetres / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.Torque"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Torque"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Torque"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static Torque operator +(Torque left, Torque right)
+        {
+            return new Torque(left.NewtonMetres + right.NewtonMetres);
+        }
+
+        /// <summary>
+        /// Subtracts an Torque from another Torque and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Torque"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Torque"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Torque"/> (the subtrahend).</param>
+        public static Torque operator -(Torque left, Torque right)
+        {
+            return new Torque(left.NewtonMetres - right.NewtonMetres);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.Torque"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Torque"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="Torque">A <see cref="T:Gu.Units.Torque"/></param>
+        public static Torque operator -(Torque Torque)
+        {
+            return new Torque(-1 * Torque.NewtonMetres);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.Torque"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="Torque"/>.
+        /// </returns>
+        /// <param name="Torque">A <see cref="T:Gu.Units.Torque"/></param>
+        public static Torque operator +(Torque Torque)
+        {
+            return Torque;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, TorqueUnit.NewtonMetres);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, TorqueUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.NewtonMetres);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.Torque"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.Torque"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.Torque"/> object to compare to this instance.</param>
+        public int CompareTo(Torque quantity)
+        {
+            return this.NewtonMetres.CompareTo(quantity.NewtonMetres);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Torque"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Torque as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Torque"/> object to compare with this instance.</param>
+        public bool Equals(Torque other)
+        {
+            return this.NewtonMetres.Equals(other.NewtonMetres);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Torque"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Torque as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Torque"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(Torque other, double tolerance)
+        {
+            return Math.Abs(this.NewtonMetres - other.NewtonMetres) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is Torque && this.Equals((Torque)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.NewtonMetres.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.NewtonMetres, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.NewtonMetres);
+        }
+    }
+}
diff --git a/Gu.Units/TorqueUnit.generated.cs b/Gu.Units/TorqueUnit.generated.cs
new file mode 100644
index 00000000..5e4a544e
--- /dev/null
+++ b/Gu.Units/TorqueUnit.generated.cs
@@ -0,0 +1,67 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.TorqueUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct TorqueUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.NewtonMetres"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly TorqueUnit NewtonMetres = new TorqueUnit(1.0, "N⋅m");
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public TorqueUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.NewtonMetres"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static Torque operator *(double left, TorqueUnit right)
+        {
+            return Torque.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.NewtonMetres"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from NewtonMetres.
+        /// </summary>
+        /// <param name="value">The value in NewtonMetres</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), NewtonMetres.Symbol);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gu.Units/Voltage.generated.cs b/Gu.Units/Voltage.generated.cs
new file mode 100644
index 00000000..375891e9
--- /dev/null
+++ b/Gu.Units/Voltage.generated.cs
@@ -0,0 +1,468 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.Voltage"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct Voltage : IComparable<Voltage>, IEquatable<Voltage>, IFormattable, IXmlSerializable, IQuantity<MassUnit, I1, LengthUnit, I2, TimeUnit, INeg3, CurrentUnit, INeg1>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.Volts"/>.
+        /// </summary>
+        public readonly double Volts;
+
+        private Voltage(double volts)
+        {
+            Volts = volts;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.Volts"/>.</param>
+        public Voltage(double value, VoltageUnit unit)
+        {
+            Volts = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in Volts
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return Volts;
+            }
+        }
+
+        /// <summary>
+        /// The quantity in millivolts
+        /// </summary>
+        public double Millivolts
+        {
+            get
+            {
+                return VoltageUnit.Millivolts.FromSiUnit(Volts);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in kilovolts
+        /// </summary>
+        public double Kilovolts
+        {
+            get
+            {
+                return VoltageUnit.Kilovolts.FromSiUnit(Volts);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in megavolts
+        /// </summary>
+        public double Megavolts
+        {
+            get
+            {
+                return VoltageUnit.Megavolts.FromSiUnit(Volts);
+            }
+        }
+
+        /// <summary>
+        /// The quantity in microvolts
+        /// </summary>
+        public double Microvolts
+        {
+            get
+            {
+                return VoltageUnit.Microvolts.FromSiUnit(Volts);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.Voltage"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.Voltage"/></param>
+        /// <returns></returns>
+        public static Voltage Parse(string s)
+        {
+            return Parser.Parse<VoltageUnit, Voltage>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.Voltage"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.Voltage"/></returns>
+        public static Voltage ReadFrom(XmlReader reader)
+        {
+            var v = new Voltage();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static Voltage From(double value, VoltageUnit unit)
+        {
+            return new Voltage(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="volts">The value in <see cref="T:Gu.Units.Volts"/></param>
+        public static Voltage FromVolts(double volts)
+        {
+            return new Voltage(volts);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="millivolts">The value in mV</param>
+        public static Voltage FromMillivolts(double millivolts)
+        {
+            return From(millivolts, VoltageUnit.Millivolts);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="kilovolts">The value in kV</param>
+        public static Voltage FromKilovolts(double kilovolts)
+        {
+            return From(kilovolts, VoltageUnit.Kilovolts);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="megavolts">The value in MV</param>
+        public static Voltage FromMegavolts(double megavolts)
+        {
+            return From(megavolts, VoltageUnit.Megavolts);
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <param name="microvolts">The value in µV</param>
+        public static Voltage FromMicrovolts(double microvolts)
+        {
+            return From(microvolts, VoltageUnit.Microvolts);
+        }
+
+        public static Power operator *(Voltage left, Current right)
+        {
+            return Power.FromWatts(left.Volts * right.Amperes);
+        }
+
+        public static Resistance operator /(Voltage left, Current right)
+        {
+            return Resistance.FromOhm(left.Volts / right.Amperes);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Voltage"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Voltage"/>.</param>
+        public static bool operator ==(Voltage left, Voltage right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.Voltage"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Voltage"/>.</param>
+        public static bool operator !=(Voltage left, Voltage right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Voltage"/> is less than another specified <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        public static bool operator <(Voltage left, Voltage right)
+        {
+            return left.Volts < right.Volts;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Voltage"/> is greater than another specified <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        public static bool operator >(Voltage left, Voltage right)
+        {
+            return left.Volts > right.Volts;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Voltage"/> is less than or equal to another specified <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        public static bool operator <=(Voltage left, Voltage right)
+        {
+            return left.Volts <= right.Volts;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.Voltage"/> is greater than or equal to another specified <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.Voltage"/>.</param>
+        public static bool operator >=(Voltage left, Voltage right)
+        {
+            return left.Volts >= right.Volts;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Voltage"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.Voltage"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Voltage"/> with <paramref name="left"/> and returns the result.</returns>
+        public static Voltage operator *(double left, Voltage right)
+        {
+            return new Voltage(left * right.Volts);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.Voltage"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Voltage"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.Voltage"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Voltage operator *(Voltage left, double right)
+        {
+            return new Voltage(left.Volts * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.Voltage"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.Voltage"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.Voltage"/> with <paramref name="right"/> and returns the result.</returns>
+        public static Voltage operator /(Voltage left, double right)
+        {
+            return new Voltage(left.Volts / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.Voltage"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Voltage"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Voltage"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static Voltage operator +(Voltage left, Voltage right)
+        {
+            return new Voltage(left.Volts + right.Volts);
+        }
+
+        /// <summary>
+        /// Subtracts an Voltage from another Voltage and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Voltage"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.Voltage"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.Voltage"/> (the subtrahend).</param>
+        public static Voltage operator -(Voltage left, Voltage right)
+        {
+            return new Voltage(left.Volts - right.Volts);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.Voltage"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.Voltage"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="Voltage">A <see cref="T:Gu.Units.Voltage"/></param>
+        public static Voltage operator -(Voltage Voltage)
+        {
+            return new Voltage(-1 * Voltage.Volts);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.Voltage"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="Voltage"/>.
+        /// </returns>
+        /// <param name="Voltage">A <see cref="T:Gu.Units.Voltage"/></param>
+        public static Voltage operator +(Voltage Voltage)
+        {
+            return Voltage;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, VoltageUnit.Volts);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, VoltageUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.Volts);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.Voltage"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.Voltage"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.Voltage"/> object to compare to this instance.</param>
+        public int CompareTo(Voltage quantity)
+        {
+            return this.Volts.CompareTo(quantity.Volts);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Voltage"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Voltage as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Voltage"/> object to compare with this instance.</param>
+        public bool Equals(Voltage other)
+        {
+            return this.Volts.Equals(other.Volts);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.Voltage"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same Voltage as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.Voltage"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(Voltage other, double tolerance)
+        {
+            return Math.Abs(this.Volts - other.Volts) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is Voltage && this.Equals((Voltage)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.Volts.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.Volts, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.Volts);
+        }
+    }
+}
diff --git a/Gu.Units/VoltageUnit.generated.cs b/Gu.Units/VoltageUnit.generated.cs
new file mode 100644
index 00000000..6d845b99
--- /dev/null
+++ b/Gu.Units/VoltageUnit.generated.cs
@@ -0,0 +1,116 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.VoltageUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct VoltageUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Volts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit Volts = new VoltageUnit(1.0, "V");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Volts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit V = Volts;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Millivolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit Millivolts = new VoltageUnit(0.001, "mV");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Millivolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit mV = Millivolts;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Kilovolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit Kilovolts = new VoltageUnit(1000, "kV");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Kilovolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit kV = Kilovolts;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Megavolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit Megavolts = new VoltageUnit(1000000, "MV");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Megavolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit MV = Megavolts;
+
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Microvolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit Microvolts = new VoltageUnit(1E-06, "µV");
+        /// <summary>
+        /// The <see cref="T:Gu.Units.Microvolts"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VoltageUnit µV = Microvolts;
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public VoltageUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.Volts"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static Voltage operator *(double left, VoltageUnit right)
+        {
+            return Voltage.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.Volts"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from Volts.
+        /// </summary>
+        /// <param name="value">The value in Volts</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), Volts.Symbol);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gu.Units/Volume.generated.cs b/Gu.Units/Volume.generated.cs
index 9b5b4cc4..ba361fc7 100644
--- a/Gu.Units/Volume.generated.cs
+++ b/Gu.Units/Volume.generated.cs
@@ -145,6 +145,26 @@ public static Volume FromCubicMillimetres(double cubicMillimetres)
             return From(cubicMillimetres, VolumeUnit.CubicMillimetres);
         }
 
+        public static Mass operator *(Volume left, Density right)
+        {
+            return Mass.FromKilograms(left.CubicMetres * right.KilogramsPerCubicMetre);
+        }
+
+        public static Length operator /(Volume left, Area right)
+        {
+            return Length.FromMetres(left.CubicMetres / right.SquareMetres);
+        }
+
+        public static Area operator /(Volume left, Length right)
+        {
+            return Area.FromSquareMetres(left.CubicMetres / right.Metres);
+        }
+
+        public static VolumetricFlow operator /(Volume left, Time right)
+        {
+            return VolumetricFlow.FromCubicMetresPerSecond(left.CubicMetres / right.Seconds);
+        }
+
         /// <summary>
         /// Indicates whether two <see cref="T:Gu.Units.Volume"/> instances are equal.
         /// </summary>
diff --git a/Gu.Units/VolumetricFlow.generated.cs b/Gu.Units/VolumetricFlow.generated.cs
new file mode 100644
index 00000000..8aa16586
--- /dev/null
+++ b/Gu.Units/VolumetricFlow.generated.cs
@@ -0,0 +1,398 @@
+namespace Gu.Units
+{
+    using System;
+    using System.Globalization;
+    using System.Xml;
+    using System.Xml.Linq;
+    using System.Xml.Schema;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// A type for the quantity <see cref="T:Gu.Units.VolumetricFlow"/>.
+    /// </summary>
+    [Serializable]
+    public partial struct VolumetricFlow : IComparable<VolumetricFlow>, IEquatable<VolumetricFlow>, IFormattable, IXmlSerializable, IQuantity<LengthUnit, I3, TimeUnit, INeg1>
+    {
+        /// <summary>
+        /// The quantity in <see cref="T:Gu.Units.CubicMetresPerSecond"/>.
+        /// </summary>
+        public readonly double CubicMetresPerSecond;
+
+        private VolumetricFlow(double cubicMetresPerSecond)
+        {
+            CubicMetresPerSecond = cubicMetresPerSecond;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"><see cref="T:Gu.Units.CubicMetresPerSecond"/>.</param>
+        public VolumetricFlow(double value, VolumetricFlowUnit unit)
+        {
+            CubicMetresPerSecond = unit.ToSiUnit(value);
+        }
+
+        /// <summary>
+        /// The quantity in CubicMetresPerSecond
+        /// </summary>
+        public double SiValue
+        {
+            get
+            {
+                return CubicMetresPerSecond;
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="T:Gu.Units.VolumetricFlow"/> from its string representation
+        /// </summary>
+        /// <param name="s">The string representation of the <see cref="T:Gu.Units.VolumetricFlow"/></param>
+        /// <returns></returns>
+        public static VolumetricFlow Parse(string s)
+        {
+            return Parser.Parse<VolumetricFlowUnit, VolumetricFlow>(s, From);
+        }
+
+        /// <summary>
+        /// Reads an instance of <see cref="T:Gu.Units.VolumetricFlow"/> from the <paramref name="reader"/>
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <returns>An instance of  <see cref="T:Gu.Units.VolumetricFlow"/></returns>
+        public static VolumetricFlow ReadFrom(XmlReader reader)
+        {
+            var v = new VolumetricFlow();
+            v.ReadXml(reader);
+            return v;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="unit"></param>
+        public static VolumetricFlow From(double value, VolumetricFlowUnit unit)
+        {
+            return new VolumetricFlow(unit.ToSiUnit(value));
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <param name="cubicMetresPerSecond">The value in <see cref="T:Gu.Units.CubicMetresPerSecond"/></param>
+        public static VolumetricFlow FromCubicMetresPerSecond(double cubicMetresPerSecond)
+        {
+            return new VolumetricFlow(cubicMetresPerSecond);
+        }
+
+        public static Area operator /(VolumetricFlow left, Speed right)
+        {
+            return Area.FromSquareMetres(left.CubicMetresPerSecond / right.MetresPerSecond);
+        }
+
+        public static Volume operator *(VolumetricFlow left, Time right)
+        {
+            return Volume.FromCubicMetres(left.CubicMetresPerSecond * right.Seconds);
+        }
+
+        public static Speed operator /(VolumetricFlow left, Area right)
+        {
+            return Speed.FromMetresPerSecond(left.CubicMetresPerSecond / right.SquareMetres);
+        }
+
+        public static Frequency operator /(VolumetricFlow left, Volume right)
+        {
+            return Frequency.FromHertz(left.CubicMetresPerSecond / right.CubicMetres);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.VolumetricFlow"/> instances are equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        public static bool operator ==(VolumetricFlow left, VolumetricFlow right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether two <see cref="T:Gu.Units.VolumetricFlow"/> instances are not equal.
+        /// </summary>
+        /// <returns>
+        /// true if the quantitys of <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">A <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        public static bool operator !=(VolumetricFlow left, VolumetricFlow right)
+        {
+            return !left.Equals(right);
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.VolumetricFlow"/> is less than another specified <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        public static bool operator <(VolumetricFlow left, VolumetricFlow right)
+        {
+            return left.CubicMetresPerSecond < right.CubicMetresPerSecond;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.VolumetricFlow"/> is greater than another specified <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than the quantity of <paramref name="right"/>; otherwise, false. 
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        public static bool operator >(VolumetricFlow left, VolumetricFlow right)
+        {
+            return left.CubicMetresPerSecond > right.CubicMetresPerSecond;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.VolumetricFlow"/> is less than or equal to another specified <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is less than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        public static bool operator <=(VolumetricFlow left, VolumetricFlow right)
+        {
+            return left.CubicMetresPerSecond <= right.CubicMetresPerSecond;
+        }
+
+        /// <summary>
+        /// Indicates whether a specified <see cref="T:Gu.Units.VolumetricFlow"/> is greater than or equal to another specified <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <returns>
+        /// true if the quantity of <paramref name="left"/> is greater than or equal to the quantity of <paramref name="right"/>; otherwise, false.
+        /// </returns>
+        /// <param name="left">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">An <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        public static bool operator >=(VolumetricFlow left, VolumetricFlow right)
+        {
+            return left.CubicMetresPerSecond >= right.CubicMetresPerSecond;
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.VolumetricFlow"/> with <paramref name="left"/> and returns the result.
+        /// </summary>
+        /// <param name="right">An instance of <see cref="T:Gu.Units.VolumetricFlow"/></param>
+        /// <param name="left">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.VolumetricFlow"/> with <paramref name="left"/> and returns the result.</returns>
+        public static VolumetricFlow operator *(double left, VolumetricFlow right)
+        {
+            return new VolumetricFlow(left * right.CubicMetresPerSecond);
+        }
+
+        /// <summary>
+        /// Multiplies an instance of <see cref="T:Gu.Units.VolumetricFlow"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.VolumetricFlow"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Multiplies an instance of <see cref="T:Gu.Units.VolumetricFlow"/> with <paramref name="right"/> and returns the result.</returns>
+        public static VolumetricFlow operator *(VolumetricFlow left, double right)
+        {
+            return new VolumetricFlow(left.CubicMetresPerSecond * right);
+        }
+
+        /// <summary>
+        /// Divides an instance of <see cref="T:Gu.Units.VolumetricFlow"/> with <paramref name="right"/> and returns the result.
+        /// </summary>
+        /// <param name="left">An instance of <see cref="T:Gu.Units.VolumetricFlow"/></param>
+        /// <param name="right">An instance of <seealso cref="T:System.Double"/></param>
+        /// <returns>Divides an instance of <see cref="T:Gu.Units.VolumetricFlow"/> with <paramref name="right"/> and returns the result.</returns>
+        public static VolumetricFlow operator /(VolumetricFlow left, double right)
+        {
+            return new VolumetricFlow(left.CubicMetresPerSecond / right);
+        }
+
+        /// <summary>
+        /// Adds two specified <see cref="T:Gu.Units.VolumetricFlow"/> instances.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.VolumetricFlow"/> whose quantity is the sum of the quantitys of <paramref name="left"/> and <paramref name="right"/>.
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.VolumetricFlow"/>.</param>
+        /// <param name="right">A TimeSpan.</param>
+        public static VolumetricFlow operator +(VolumetricFlow left, VolumetricFlow right)
+        {
+            return new VolumetricFlow(left.CubicMetresPerSecond + right.CubicMetresPerSecond);
+        }
+
+        /// <summary>
+        /// Subtracts an VolumetricFlow from another VolumetricFlow and returns the difference.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.VolumetricFlow"/> that is the difference
+        /// </returns>
+        /// <param name="left">A <see cref="T:Gu.Units.VolumetricFlow"/> (the minuend).</param>
+        /// <param name="right">A <see cref="T:Gu.Units.VolumetricFlow"/> (the subtrahend).</param>
+        public static VolumetricFlow operator -(VolumetricFlow left, VolumetricFlow right)
+        {
+            return new VolumetricFlow(left.CubicMetresPerSecond - right.CubicMetresPerSecond);
+        }
+
+        /// <summary>
+        /// Returns an <see cref="T:Gu.Units.VolumetricFlow"/> whose quantity is the negated quantity of the specified instance.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:Gu.Units.VolumetricFlow"/> with the same numeric quantity as this instance, but the opposite sign.
+        /// </returns>
+        /// <param name="VolumetricFlow">A <see cref="T:Gu.Units.VolumetricFlow"/></param>
+        public static VolumetricFlow operator -(VolumetricFlow VolumetricFlow)
+        {
+            return new VolumetricFlow(-1 * VolumetricFlow.CubicMetresPerSecond);
+        }
+
+        /// <summary>
+        /// Returns the specified instance of <see cref="T:Gu.Units.VolumetricFlow"/>.
+        /// </summary>
+        /// <returns>
+        /// Returns <paramref name="VolumetricFlow"/>.
+        /// </returns>
+        /// <param name="VolumetricFlow">A <see cref="T:Gu.Units.VolumetricFlow"/></param>
+        public static VolumetricFlow operator +(VolumetricFlow VolumetricFlow)
+        {
+            return VolumetricFlow;
+        }
+
+        public override string ToString()
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, (IFormatProvider)NumberFormatInfo.CurrentInfo);
+        }
+
+        public string ToString(IFormatProvider provider)
+        {
+            return this.ToString((string)null, (IFormatProvider)NumberFormatInfo.GetInstance(provider));
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return this.ToString(format, formatProvider, VolumetricFlowUnit.CubicMetresPerSecond);
+        }
+
+        public string ToString(string format, IFormatProvider formatProvider, VolumetricFlowUnit unit)
+        {
+            var quantity = unit.FromSiUnit(this.CubicMetresPerSecond);
+            return string.Format("{0}{1}", quantity.ToString(format, formatProvider), unit.Symbol);
+        }
+
+        /// <summary>
+        /// Compares this instance to a specified <see cref="T:MathNet.Spatial.Units.VolumetricFlow"/> object and returns an integer that indicates whether this <see cref="instance"/> is shorter than, equal to, or longer than the <see cref="T:MathNet.Spatial.Units.VolumetricFlow"/> object.
+        /// </summary>
+        /// <returns>
+        /// A signed number indicating the relative quantitys of this instance and <paramref name="quantity"/>.
+        /// 
+        ///                     Value
+        /// 
+        ///                     Description
+        /// 
+        ///                     A negative integer
+        /// 
+        ///                     This instance is smaller than <paramref name="quantity"/>.
+        /// 
+        ///                     Zero
+        /// 
+        ///                     This instance is equal to <paramref name="quantity"/>.
+        /// 
+        ///                     A positive integer
+        /// 
+        ///                     This instance is larger than <paramref name="quantity"/>.
+        /// 
+        /// </returns>
+        /// <param name="quantity">A <see cref="T:MathNet.Spatial.Units.VolumetricFlow"/> object to compare to this instance.</param>
+        public int CompareTo(VolumetricFlow quantity)
+        {
+            return this.CubicMetresPerSecond.CompareTo(quantity.CubicMetresPerSecond);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.VolumetricFlow"/> object.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same VolumetricFlow as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.VolumetricFlow"/> object to compare with this instance.</param>
+        public bool Equals(VolumetricFlow other)
+        {
+            return this.CubicMetresPerSecond.Equals(other.CubicMetresPerSecond);
+        }
+
+        /// <summary>
+        /// Returns a quantity indicating whether this instance is equal to a specified <see cref="T:Gu.Units.VolumetricFlow"/> object within the given tolerance.
+        /// </summary>
+        /// <returns>
+        /// true if <paramref name="other"/> represents the same VolumetricFlow as this instance; otherwise, false.
+        /// </returns>
+        /// <param name="other">An <see cref="T:Gu.Units.VolumetricFlow"/> object to compare with this instance.</param>
+        /// <param name="tolerance">The maximum difference for being considered equal</param>
+        public bool Equals(VolumetricFlow other, double tolerance)
+        {
+            return Math.Abs(this.CubicMetresPerSecond - other.CubicMetresPerSecond) < tolerance;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is VolumetricFlow && this.Equals((VolumetricFlow)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.CubicMetresPerSecond.GetHashCode();
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used. When implementing the IXmlSerializable interface, 
+        /// you should return null (Nothing in Visual Basic) from this method, and instead, 
+        /// if specifying a custom schema is required, apply the <see cref="T:System.Xml.Serialization.XmlSchemaProviderAttribute"/> to the class.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the
+        ///  <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> 
+        /// method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        public XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an object from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. </param>
+        public void ReadXml(XmlReader reader)
+        {
+            // Hacking set readonly fields here, can't think of a cleaner workaround
+            XmlExt.SetReadonlyField(ref this, x => x.CubicMetresPerSecond, reader, "Value");
+        }
+
+        /// <summary>
+        /// Converts an object into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized. </param>
+        public void WriteXml(XmlWriter writer)
+        {
+            XmlExt.WriteAttribute(writer, "Value", this.CubicMetresPerSecond);
+        }
+    }
+}
diff --git a/Gu.Units/VolumetricFlowUnit.generated.cs b/Gu.Units/VolumetricFlowUnit.generated.cs
new file mode 100644
index 00000000..b40f2982
--- /dev/null
+++ b/Gu.Units/VolumetricFlowUnit.generated.cs
@@ -0,0 +1,67 @@
+namespace Gu.Units
+{
+    using System;
+    /// <summary>
+    /// A type for the unit <see cref="T:Gu.Units.VolumetricFlowUnit"/>.
+    /// Contains conversion logic.
+    /// </summary>
+    [Serializable]
+    public struct VolumetricFlowUnit : IUnit
+    {
+        /// <summary>
+        /// The <see cref="T:Gu.Units.CubicMetresPerSecond"/> unit
+        /// Contains coonversion logic to from and formatting.
+        /// </summary>
+        public static readonly VolumetricFlowUnit CubicMetresPerSecond = new VolumetricFlowUnit(1.0, "m³ / s");
+
+        private readonly double _conversionFactor;
+        private readonly string _symbol;
+
+        public VolumetricFlowUnit(double conversionFactor, string symbol)
+        {
+            _conversionFactor = conversionFactor;
+            _symbol = symbol;
+        }
+
+        /// <summary>
+        /// The symbol for <see cref="T:Gu.Units.CubicMetresPerSecond"/>.
+        /// </summary>
+        public string Symbol
+        {
+            get
+            {
+                return _symbol;
+            }
+        }
+
+        public static VolumetricFlow operator *(double left, VolumetricFlowUnit right)
+        {
+            return VolumetricFlow.From(left, right);
+        }
+
+        /// <summary>
+        /// Converts a value to <see cref="T:Gu.Units.CubicMetresPerSecond"/>.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns>The converted value</returns>
+        public double ToSiUnit(double value)
+        {
+            return _conversionFactor * value;
+        }
+
+        /// <summary>
+        /// Converts a value from CubicMetresPerSecond.
+        /// </summary>
+        /// <param name="value">The value in CubicMetresPerSecond</param>
+        /// <returns>The converted value</returns>
+        public double FromSiUnit(double value)
+        {
+            return value / _conversionFactor;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("1{0} == {1}{2}", _symbol, this.ToSiUnit(1), CubicMetresPerSecond.Symbol);
+        }
+    }
+}
\ No newline at end of file