From dd0e1710fe7e1573127ecc7a210149a47f4c0257 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 10:31:09 +0000
Subject: [PATCH 1/8] [patch] Resolve dot segments in IsRoot,
 DirectoryPath.Parent and Depth; skip unrepresentable entries in GetContents

IsRoot is now true exactly when Parent returns the path itself, so
walking upwards from /home/.. stops (#479). DirectoryPath.Parent
resolves rooted paths and normalizes relative ones as the typed paths
do (#478). Depth counts directories below the root of the resolved
path, or levels below the first segment of the normalized relative
path, instead of separator characters (#466). GetContents skips an
entry whose path fails validation rather than throwing for the whole
listing (#445).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 .../Implementations/AbsoluteDirectoryPath.cs  |  42 ++--
 .../Implementations/RelativeDirectoryPath.cs  |  29 ++-
 Semantics.Paths/Primitives/DirectoryPath.cs   |  21 +-
 Semantics.Paths/SemanticDirectoryPath.cs      |  44 +++-
 .../Utilities/SpanPathUtilities.cs            |  23 +++
 Semantics.Test/Paths/DotSegmentPathTests.cs   | 192 ++++++++++++++++++
 6 files changed, 307 insertions(+), 44 deletions(-)
 create mode 100644 Semantics.Test/Paths/DotSegmentPathTests.cs

diff --git a/Semantics.Paths/Implementations/AbsoluteDirectoryPath.cs b/Semantics.Paths/Implementations/AbsoluteDirectoryPath.cs
index f71405cc..025c185d 100644
--- a/Semantics.Paths/Implementations/AbsoluteDirectoryPath.cs
+++ b/Semantics.Paths/Implementations/AbsoluteDirectoryPath.cs
@@ -72,20 +72,33 @@ public AbsoluteDirectoryPath Parent
 	/// Gets the name of this directory (the last component of the path).
 	/// </summary>
 	/// <value>A <see cref="FileName"/> representing just the directory name.</value>
+	/// <remarks>
+	/// This is the last component as written, not as resolved: the name of <c>/home/user/..</c> is <c>..</c>.
+	/// Resolve the path first, for example through <see cref="Parent"/> of a child, when the directory's own
+	/// name is wanted.
+	/// </remarks>
 	public FileName Name => _cachedName ??= FileName.Create<FileName>(Path.GetFileName(WeakString) ?? "");
 
 	// Cache for depth calculation
 	private int? _cachedDepth;
 
 	/// <summary>
-	/// Gets the depth of this directory path (number of directory separators).
-	/// For example, "a/b/c" has depth 2, "a" has depth 0.
+	/// Gets the depth of this directory below its root: the number of directories between the root and this one,
+	/// counting this one.
 	/// </summary>
-	/// <value>The number of directory separators in the path.</value>
+	/// <value>
+	/// 0 for a root such as <c>/</c> or <c>C:\</c>, 1 for <c>/home</c>, 2 for <c>/home/user</c>. <c>.</c> and
+	/// <c>..</c> segments are resolved first, so <c>/home/user/..</c> has depth 1, and a trailing separator
+	/// does not add a level.
+	/// </value>
+	/// <remarks>
+	/// The depth always agrees with <see cref="Parent"/>: a path that is not a root is exactly one level deeper
+	/// than its parent.
+	/// </remarks>
 	public int Depth => _cachedDepth ??= CalculateDepth(WeakString);
 
 	/// <summary>
-	/// Calculates directory depth using span semantics for optimal performance.
+	/// Counts the segments after the root of the resolved path.
 	/// </summary>
 	/// <param name="path">The path to analyze.</param>
 	/// <returns>The directory depth.</returns>
@@ -96,16 +109,9 @@ private static int CalculateDepth(string path)
 			return 0;
 		}
 
-		ReadOnlySpan<char> span = path.AsSpan();
-		int depth = 0;
-		for (int i = 0; i < span.Length; i++)
-		{
-			if (span[i] == Path.DirectorySeparatorChar || span[i] == Path.AltDirectorySeparatorChar)
-			{
-				depth++;
-			}
-		}
-		return depth;
+		string full = Path.GetFullPath(path);
+		string root = Path.GetPathRoot(full) ?? string.Empty;
+		return SpanPathUtilities.CountSegments(full.AsSpan(root.Length));
 	}
 
 	// Cache for root check
@@ -114,8 +120,12 @@ private static int CalculateDepth(string path)
 	/// <summary>
 	/// Determines whether this directory is a root directory.
 	/// </summary>
-	/// <value><c>true</c> if this is a root directory; otherwise, <c>false</c>.</value>
-	public bool IsRoot => _cachedIsRoot ??= Path.GetPathRoot(WeakString) == WeakString;
+	/// <value>
+	/// <see langword="true"/> if this path resolves to a root, which is exactly when <see cref="Parent"/> returns
+	/// this same path; otherwise, <see langword="false"/>. <c>.</c> and <c>..</c> segments are resolved first, so
+	/// <c>/home/..</c> is a root.
+	/// </value>
+	public bool IsRoot => _cachedIsRoot ??= ReferenceEquals(Parent, this);
 
 	/// <summary>
 	/// Creates an absolute file path for files in this directory.
diff --git a/Semantics.Paths/Implementations/RelativeDirectoryPath.cs b/Semantics.Paths/Implementations/RelativeDirectoryPath.cs
index 4809e980..2dc3337e 100644
--- a/Semantics.Paths/Implementations/RelativeDirectoryPath.cs
+++ b/Semantics.Paths/Implementations/RelativeDirectoryPath.cs
@@ -78,33 +78,28 @@ private RelativeDirectoryPath ComputeParent()
 	private int? _cachedDepth;
 
 	/// <summary>
-	/// Gets the depth of this relative directory path (number of directory levels).
+	/// Gets the depth of this relative directory path: the number of levels below its first segment.
 	/// </summary>
-	/// <value>The depth of the directory path.</value>
-	public int Depth => _cachedDepth ??= CalculateDepth(WeakString);
+	/// <value>
+	/// 0 for <c>a</c>, 1 for <c>a/b</c>, 2 for <c>a/b/c</c>. The path is normalized first, the same way as
+	/// <see cref="Normalize"/>, so <c>./a</c> has the same depth as <c>a</c>, a trailing separator does not add a
+	/// level, and <c>a/..</c>, <c>.</c> and the empty path, which all name the starting directory, have depth 0.
+	/// </value>
+	public int Depth => _cachedDepth ??= CalculateDepth();
 
 	/// <summary>
-	/// Calculates directory depth using span semantics for optimal performance.
+	/// Counts the segments of the normalized path, less the first.
 	/// </summary>
-	/// <param name="path">The path to analyze.</param>
 	/// <returns>The directory depth.</returns>
-	private static int CalculateDepth(string path)
+	private int CalculateDepth()
 	{
-		if (string.IsNullOrEmpty(path))
+		string normalized = Normalize().WeakString;
+		if (normalized.Length == 0 || normalized == ".")
 		{
 			return 0;
 		}
 
-		ReadOnlySpan<char> span = path.AsSpan();
-		int depth = 0;
-		for (int i = 0; i < span.Length; i++)
-		{
-			if (span[i] == Path.DirectorySeparatorChar || span[i] == Path.AltDirectorySeparatorChar)
-			{
-				depth++;
-			}
-		}
-		return depth;
+		return SpanPathUtilities.CountSegments(normalized.AsSpan()) - 1;
 	}
 
 	/// <summary>
diff --git a/Semantics.Paths/Primitives/DirectoryPath.cs b/Semantics.Paths/Primitives/DirectoryPath.cs
index 6ec43c43..9c325bed 100644
--- a/Semantics.Paths/Primitives/DirectoryPath.cs
+++ b/Semantics.Paths/Primitives/DirectoryPath.cs
@@ -12,13 +12,28 @@ public sealed record DirectoryPath : SemanticDirectoryPath<DirectoryPath>, IDire
 	/// <summary>
 	/// Gets the parent directory of this directory path.
 	/// </summary>
-	/// <value>A <see cref="DirectoryPath"/> representing the parent directory, or an empty path if this is a root directory.</value>
+	/// <value>
+	/// A <see cref="DirectoryPath"/> naming the directory that contains this one, or an empty path when this path
+	/// resolves to a root directory.
+	/// </value>
+	/// <remarks>
+	/// <c>.</c> and <c>..</c> segments are resolved before the last segment is dropped, so the parent of
+	/// <c>/home/user/..</c> is <c>/</c> rather than <c>/home/user</c>. A rooted path is resolved as
+	/// <see cref="AbsoluteDirectoryPath.Parent"/> resolves it, and a relative one is normalized lexically as
+	/// <see cref="RelativeDirectoryPath.Parent"/> normalizes it, so it is never resolved against the working
+	/// directory: the parent of <c>a/..</c> is <c>..</c>, and the parent of <c>..</c> is <c>../..</c>.
+	/// </remarks>
 	public DirectoryPath Parent
 	{
 		get
 		{
-			string? parentPath = Path.GetDirectoryName(WeakString);
-			return Create<DirectoryPath>(parentPath ?? "");
+			if (Path.IsPathRooted(WeakString))
+			{
+				string? parent = Path.GetDirectoryName(Path.GetFullPath(WeakString));
+				return Create<DirectoryPath>(parent ?? "");
+			}
+
+			return Create<DirectoryPath>(RelativeDirectoryPath.Create<RelativeDirectoryPath>(WeakString).Parent.WeakString);
 		}
 	}
 
diff --git a/Semantics.Paths/SemanticDirectoryPath.cs b/Semantics.Paths/SemanticDirectoryPath.cs
index c5b9c8d3..3e0bca72 100644
--- a/Semantics.Paths/SemanticDirectoryPath.cs
+++ b/Semantics.Paths/SemanticDirectoryPath.cs
@@ -17,12 +17,17 @@ public abstract record SemanticDirectoryPath<TDerived> : SemanticPath<TDerived>
 	/// Returns an empty collection if the directory doesn't exist or cannot be accessed.
 	/// </value>
 	/// <remarks>
+	/// An entry whose path this library cannot represent, for example one that fails path validation because its
+	/// name holds a character such as <c>|</c> or its full path is too long, is skipped rather than failing the
+	/// whole listing, so every entry that can be represented is still returned.
+	/// <para>
 	/// The returned types depend on the current directory type:
 	/// <list type="bullet">
 	/// <item><description><see cref="AbsoluteDirectoryPath"/> returns <see cref="AbsoluteFilePath"/> and <see cref="AbsoluteDirectoryPath"/> objects</description></item>
 	/// <item><description><see cref="RelativeDirectoryPath"/> returns <see cref="RelativeFilePath"/> and <see cref="RelativeDirectoryPath"/> objects</description></item>
 	/// <item><description><see cref="DirectoryPath"/> returns <see cref="FilePath"/> and <see cref="DirectoryPath"/> objects</description></item>
 	/// </list>
+	/// </para>
 	/// </remarks>
 	public virtual IEnumerable<IPath> GetContents()
 	{
@@ -41,15 +46,10 @@ public virtual IEnumerable<IPath> GetContents()
 
 			foreach (string entry in entries)
 			{
-				if (File.Exists(entry))
+				IPath? item = TryCreateEntry(entry);
+				if (item is not null)
 				{
-					// It's a file - create appropriate file path type
-					contents.Add(CreateFilePath(entry));
-				}
-				else if (Directory.Exists(entry))
-				{
-					// It's a directory - create appropriate directory path type
-					contents.Add(CreateDirectoryPath(entry));
+					contents.Add(item);
 				}
 			}
 
@@ -67,6 +67,34 @@ public virtual IEnumerable<IPath> GetContents()
 		}
 	}
 
+	/// <summary>
+	/// Wraps one directory entry as the appropriate path type, or returns <see langword="null"/> when the entry is
+	/// neither a file nor a directory any more, or its path fails validation.
+	/// </summary>
+	/// <param name="entry">The entry's path, as listed.</param>
+	/// <returns>The wrapped entry, or <see langword="null"/> to skip it.</returns>
+	private IPath? TryCreateEntry(string entry)
+	{
+		try
+		{
+			if (File.Exists(entry))
+			{
+				return CreateFilePath(entry);
+			}
+
+			if (Directory.Exists(entry))
+			{
+				return CreateDirectoryPath(entry);
+			}
+		}
+		catch (ArgumentException)
+		{
+			// The entry's path fails validation, which says nothing about its siblings.
+		}
+
+		return null;
+	}
+
 	/// <summary>
 	/// Creates an appropriate file path type based on the current directory path type.
 	/// </summary>
diff --git a/Semantics.Paths/Utilities/SpanPathUtilities.cs b/Semantics.Paths/Utilities/SpanPathUtilities.cs
index da8413ad..8648d536 100644
--- a/Semantics.Paths/Utilities/SpanPathUtilities.cs
+++ b/Semantics.Paths/Utilities/SpanPathUtilities.cs
@@ -150,4 +150,27 @@ public static bool EndsWithDirectorySeparator(string path)
 			   (path[path.Length - 1] == Path.DirectorySeparatorChar || path[path.Length - 1] == Path.AltDirectorySeparatorChar);
 #endif
 	}
+
+	/// <summary>
+	/// Counts the non-empty segments of a path, so repeated, leading and trailing separators add nothing.
+	/// </summary>
+	/// <param name="path">The path span to count, without its root.</param>
+	/// <returns>The number of segments.</returns>
+	public static int CountSegments(ReadOnlySpan<char> path)
+	{
+		int count = 0;
+		bool inSegment = false;
+		foreach (char c in path)
+		{
+			bool isSeparator = c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar;
+			if (!isSeparator && !inSegment)
+			{
+				count++;
+			}
+
+			inSegment = !isSeparator;
+		}
+
+		return count;
+	}
 }
diff --git a/Semantics.Test/Paths/DotSegmentPathTests.cs b/Semantics.Test/Paths/DotSegmentPathTests.cs
new file mode 100644
index 00000000..9bcf78fb
--- /dev/null
+++ b/Semantics.Test/Paths/DotSegmentPathTests.cs
@@ -0,0 +1,192 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Test.Paths;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using ktsu.Semantics.Paths;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Tests that <c>.</c> and <c>..</c> segments are resolved by <see cref="AbsoluteDirectoryPath.IsRoot"/>,
+/// <see cref="DirectoryPath.Parent"/> and both <c>Depth</c> properties, and that a directory listing survives an
+/// entry the library cannot represent.
+/// </summary>
+[TestClass]
+public class DotSegmentPathTests
+{
+	private static AbsoluteDirectoryPath Absolute(string path) => AbsoluteDirectoryPath.Create<AbsoluteDirectoryPath>(path);
+
+	private static RelativeDirectoryPath Relative(string path) => RelativeDirectoryPath.Create<RelativeDirectoryPath>(path);
+
+	private static DirectoryPath Polymorphic(string path) => DirectoryPath.Create<DirectoryPath>(path);
+
+	private static readonly string[] ValidEntries = ["ok.txt", "sub"];
+
+	private static readonly string Sep = Path.DirectorySeparatorChar.ToString();
+
+	/// <summary>Issue #479: a path that resolves to a root is a root.</summary>
+	[TestMethod]
+	public void IsRoot_IsTrueExactlyWhenParentIsThePathItself()
+	{
+		string[] paths =
+		[
+			TestPaths.Root,
+			TestPaths.Absolute("home", ".."),
+			TestPaths.Absolute("home", "user", "..", ".."),
+			TestPaths.Absolute("home"),
+			TestPaths.Absolute("home", "user", ".."),
+		];
+
+		foreach (string path in paths)
+		{
+			AbsoluteDirectoryPath dir = Absolute(path);
+			Assert.AreEqual(ReferenceEquals(dir.Parent, dir), dir.IsRoot, path);
+		}
+
+		Assert.IsTrue(Absolute(TestPaths.Absolute("home", "..")).IsRoot);
+		Assert.IsFalse(Absolute(TestPaths.Absolute("home", "user", "..")).IsRoot);
+	}
+
+	/// <summary>Issue #479: the documented upward walk stops at the root from a dotted path.</summary>
+	[TestMethod]
+	public void WalkingUpwards_FromADottedPath_StopsAtTheRoot()
+	{
+		foreach (string start in new[] { TestPaths.Absolute("home", ".."), TestPaths.Absolute("a", "b", "..", "c", ".") })
+		{
+			AbsoluteDirectoryPath dir = Absolute(start);
+			int steps = 0;
+			while (!dir.IsRoot)
+			{
+				dir = dir.Parent;
+				Assert.IsLessThan(10, ++steps, $"Walking up from '{start}' did not stop.");
+			}
+
+			Assert.AreEqual(TestPaths.Root, Path.GetFullPath(dir.WeakString));
+		}
+	}
+
+	/// <summary>Issue #478: the polymorphic primitive resolves dot segments like the typed paths do.</summary>
+	[TestMethod]
+	public void DirectoryPathParent_ResolvesDotSegments()
+	{
+		Assert.AreEqual(TestPaths.Root, Polymorphic(TestPaths.Absolute("home", "user", "..")).Parent.WeakString);
+		Assert.AreEqual(TestPaths.Absolute("home"), Polymorphic(TestPaths.Absolute("home", "user", ".")).Parent.WeakString);
+		Assert.AreEqual("..", Polymorphic("a" + Sep + "..").Parent.WeakString);
+		Assert.AreEqual(".." + Sep + "..", Polymorphic("..").Parent.WeakString);
+		Assert.AreEqual("a", Polymorphic("a" + Sep + "." + Sep + "b").Parent.WeakString);
+	}
+
+	[TestMethod]
+	public void DirectoryPathParent_OfARoot_IsEmpty()
+	{
+		Assert.AreEqual("", Polymorphic(TestPaths.Root).Parent.WeakString);
+		Assert.AreEqual("", Polymorphic(TestPaths.Absolute("home", "..")).Parent.WeakString);
+	}
+
+	/// <summary>Issue #466: depth counts directories below the root, not separator characters.</summary>
+	[TestMethod]
+	public void AbsoluteDepth_CountsDirectoriesBelowTheRoot()
+	{
+		Assert.AreEqual(0, Absolute(TestPaths.Root).Depth);
+		Assert.AreEqual(1, Absolute(TestPaths.Absolute("home")).Depth);
+		Assert.AreEqual(1, Absolute(TestPaths.Absolute("home") + Sep).Depth);
+		Assert.AreEqual(2, Absolute(TestPaths.Absolute("home", "user")).Depth);
+		Assert.AreEqual(1, Absolute(TestPaths.Absolute("home", "user", "..")).Depth);
+		Assert.AreEqual(0, Absolute(TestPaths.Absolute("home", "..")).Depth);
+	}
+
+	[TestMethod]
+	public void AbsoluteDepth_IsOneMoreThanTheParents()
+	{
+		AbsoluteDirectoryPath dir = Absolute(TestPaths.Absolute("a", "b", "c"));
+		while (!dir.IsRoot)
+		{
+			Assert.AreEqual(dir.Parent.Depth + 1, dir.Depth, dir.WeakString);
+			dir = dir.Parent;
+		}
+	}
+
+	[TestMethod]
+	[OSCondition(OperatingSystems.Windows)]
+	[TestCategory("OS-Specific")]
+	public void AbsoluteDepth_OnWindowsRoots()
+	{
+		Assert.AreEqual(0, Absolute(@"C:\").Depth);
+		Assert.AreEqual(1, Absolute(@"C:\Users").Depth);
+	}
+
+	[TestMethod]
+	public void RelativeDepth_IsTakenFromTheNormalizedPath()
+	{
+		Assert.AreEqual(0, Relative("a").Depth);
+		Assert.AreEqual(1, Relative("a" + Sep + "b").Depth);
+		Assert.AreEqual(0, Relative("." + Sep + "a").Depth);
+		Assert.AreEqual(0, Relative("a" + Sep).Depth);
+		Assert.AreEqual(0, Relative("a" + Sep + "..").Depth);
+		Assert.AreEqual(0, Relative(".").Depth);
+		Assert.AreEqual(1, Relative("a" + Sep + "." + Sep + "b").Depth);
+	}
+
+	/// <summary>
+	/// A directory type whose entries fail validation by name, standing in for the names and lengths only some
+	/// platforms reject, so the listing contract is tested on every platform.
+	/// </summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1812:Avoid uninstantiated internal classes", Justification = "Created through SemanticString.Create<T>")]
+	private sealed record PickyDirectoryPath : SemanticDirectoryPath<PickyDirectoryPath>
+	{
+		protected override IFilePath CreateFilePath(string filePath) =>
+			Path.GetFileName(filePath) == "bad.txt"
+				? throw new ArgumentException("Rejected for the test.", nameof(filePath))
+				: base.CreateFilePath(filePath);
+	}
+
+	/// <summary>Issue #445: one entry that fails validation does not hide the rest.</summary>
+	[TestMethod]
+	public void GetContents_SkipsAnEntryThatFailsValidation()
+	{
+		string root = Path.Combine(Path.GetTempPath(), "semantics-contents-" + Guid.NewGuid().ToString("N"));
+		Directory.CreateDirectory(root);
+		try
+		{
+			File.WriteAllText(Path.Combine(root, "ok.txt"), "ok");
+			Directory.CreateDirectory(Path.Combine(root, "sub"));
+			File.WriteAllText(Path.Combine(root, "bad.txt"), "rejected");
+
+			PickyDirectoryPath dir = PickyDirectoryPath.Create<PickyDirectoryPath>(root);
+			List<string> names = [.. dir.GetContents().Select(p => Path.GetFileName(p.ToString()) ?? "")];
+
+			CollectionAssert.AreEquivalent(ValidEntries, names);
+		}
+		finally
+		{
+			Directory.Delete(root, recursive: true);
+		}
+	}
+
+	/// <summary>Issue #445, with the real Windows length limit rather than a stand-in.</summary>
+	[TestMethod]
+	[OSCondition(OperatingSystems.Windows)]
+	[TestCategory("OS-Specific")]
+	public void GetContents_SkipsAnEntryPastTheWindowsLengthLimit()
+	{
+		string root = Path.Combine(Path.GetTempPath(), "semantics-contents-" + Guid.NewGuid().ToString("N"));
+		Directory.CreateDirectory(root);
+		try
+		{
+			File.WriteAllText(Path.Combine(root, "ok.txt"), "ok");
+			Directory.CreateDirectory(Path.Combine(root, "sub"));
+			File.WriteAllText(Path.Combine(root, new string('x', 250) + ".txt"), "too long");
+
+			List<string> names = [.. Absolute(root).GetContents().Select(p => Path.GetFileName(p.ToString()) ?? "")];
+
+			CollectionAssert.AreEquivalent(ValidEntries, names);
+		}
+		finally
+		{
+			Directory.Delete(root, recursive: true);
+		}
+	}
+}

From 6d28e5c9b129812549532f182a391690146c093b Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 10:34:50 +0000
Subject: [PATCH 2/8] [minor] Color: CSS named colors, alpha-aware contrast,
 gamut-mapped Oklab mixes

NamedColors.Green is CSS's #008000 and the new Lime is #00FF00 (#449).
CompositeOver blends source-over in gamma sRGB; ContrastRatio,
AccessibilityLevelAgainst and AdjustForContrast measure a translucent
color as it looks over the background (#393). AdjustForContrast
gamut-maps its lightness candidates by reducing chroma instead of
clipping, and falls back to mixing towards black or white, so it
reaches the target whenever black or white does (#351). MixOklab and
Gradient return in-gamut colors, and Hsl/Hsv.FromSrgb clamp their
input and treat a rounding-error spread as gray (#355).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 Semantics.Color/Color.Conversions.cs          |  10 +
 Semantics.Color/Color.Operations.cs           | 186 +++++++++++++---
 Semantics.Color/Hsl.cs                        |  14 +-
 Semantics.Color/Hsv.cs                        |   7 +-
 Semantics.Color/NamedColors.cs                |  14 +-
 Semantics.Color/README.md                     |  11 +-
 Semantics.Color/Srgb.cs                       |   4 +
 .../Colors/ColorGamutAndAlphaTests.cs         | 207 ++++++++++++++++++
 8 files changed, 409 insertions(+), 44 deletions(-)
 create mode 100644 Semantics.Test/Colors/ColorGamutAndAlphaTests.cs

diff --git a/Semantics.Color/Color.Conversions.cs b/Semantics.Color/Color.Conversions.cs
index 2bce5413..50077e96 100644
--- a/Semantics.Color/Color.Conversions.cs
+++ b/Semantics.Color/Color.Conversions.cs
@@ -120,6 +120,11 @@ private static bool IsHexDigit(char c) =>
 	/// <param name="oklab">The Oklab color.</param>
 	/// <param name="a">Straight alpha (default 1.0).</param>
 	/// <returns>The linear-RGB color.</returns>
+	/// <remarks>
+	/// The conversion is exact and does not gamut-map, so an Oklab value outside sRGB, or a round trip that lands
+	/// a rounding error past white, gives channels outside 0..1. Call <see cref="Clamp"/> on the result when an
+	/// in-gamut color is needed; <see cref="MixOklab"/> and <see cref="Gradient"/> already return one.
+	/// </remarks>
 	public static Color FromOklab(Oklab oklab, double a = 1.0) => oklab.ToColor(a);
 
 	/// <summary>Converts this linear color to <see cref="Oklch"/>.</summary>
@@ -130,6 +135,11 @@ private static bool IsHexDigit(char c) =>
 	/// <param name="oklch">The Oklch color.</param>
 	/// <param name="a">Straight alpha (default 1.0).</param>
 	/// <returns>The linear-RGB color.</returns>
+	/// <remarks>
+	/// The conversion is exact and does not gamut-map, so an Oklab value outside sRGB, or a round trip that lands
+	/// a rounding error past white, gives channels outside 0..1. Call <see cref="Clamp"/> on the result when an
+	/// in-gamut color is needed; <see cref="MixOklab"/> and <see cref="Gradient"/> already return one.
+	/// </remarks>
 	public static Color FromOklch(Oklch oklch, double a = 1.0) => oklch.ToOklab().ToColor(a);
 
 	/// <summary>Converts this linear color to <see cref="Hsl"/> (via sRGB).</summary>
diff --git a/Semantics.Color/Color.Operations.cs b/Semantics.Color/Color.Operations.cs
index 28041e17..95b3cafe 100644
--- a/Semantics.Color/Color.Operations.cs
+++ b/Semantics.Color/Color.Operations.cs
@@ -10,22 +10,65 @@ public readonly partial record struct Color
 	/// <summary>Gets the WCAG relative luminance of this color (computed on the linear channels).</summary>
 	public double RelativeLuminance => (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
 
-	/// <summary>Computes the WCAG contrast ratio (1..21) between this color and another.</summary>
-	/// <param name="other">The other color.</param>
+	/// <summary>
+	/// Composites this color over a background with the source-over operator, the way CSS and every browser
+	/// blend a translucent color onto what is beneath it.
+	/// </summary>
+	/// <param name="background">The color underneath.</param>
+	/// <returns>
+	/// The blended color, with alpha <c>a + b·(1 − a)</c> for this color's alpha <c>a</c> and the background's
+	/// <c>b</c>. An opaque background gives an opaque result.
+	/// </returns>
+	/// <remarks>
+	/// The blend is computed on the gamma-encoded sRGB channels rather than the linear ones, because that is
+	/// what browsers do and what WCAG contrast checkers such as axe and Chrome DevTools measure, so a contrast
+	/// ratio taken from the result agrees with theirs. Blending in linear light would be physically closer to
+	/// mixing light, and would disagree with every tool a reader checks the ratio against.
+	/// </remarks>
+	public Color CompositeOver(Color background)
+	{
+		double a = Clamp01(A);
+		double b = Clamp01(background.A) * (1.0 - a);
+		double alpha = a + b;
+		if (alpha <= 0.0)
+		{
+			return new Color(0.0, 0.0, 0.0, 0.0);
+		}
+
+		Srgb fg = ToSrgb();
+		Srgb bg = background.ToSrgb();
+		Srgb blended = new(
+			((fg.R * a) + (bg.R * b)) / alpha,
+			((fg.G * a) + (bg.G * b)) / alpha,
+			((fg.B * a) + (bg.B * b)) / alpha);
+		return FromSrgb(blended, alpha);
+	}
+
+	/// <summary>Computes the WCAG contrast ratio (1..21) between this color and a background.</summary>
+	/// <param name="other">The background color. Its own alpha is ignored: it is treated as opaque.</param>
 	/// <returns>The contrast ratio, from 1 (identical luminance) to 21 (black vs white).</returns>
+	/// <remarks>
+	/// A translucent color is first composited over the background with <see cref="CompositeOver"/>, as WCAG
+	/// checkers do, so the ratio measures what is actually seen: fully transparent text rates 1:1 against
+	/// anything. For two opaque colors the ratio is symmetric; when this color is translucent it is not, and
+	/// <paramref name="other"/> is the one underneath.
+	/// </remarks>
 	public double ContrastRatio(Color other)
 	{
-		double l1 = RelativeLuminance;
-		double l2 = other.RelativeLuminance;
+		Color background = other.WithAlpha(1.0);
+		Color seen = A >= 1.0 ? this : CompositeOver(background);
+		double l1 = seen.RelativeLuminance;
+		double l2 = background.RelativeLuminance;
 		double lighter = Math.Max(l1, l2);
 		double darker = Math.Min(l1, l2);
 		return (lighter + 0.05) / (darker + 0.05);
 	}
 
 	/// <summary>Rates the contrast of this color against a background per WCAG.</summary>
-	/// <param name="background">The background color.</param>
+	/// <param name="background">The background color, treated as opaque.</param>
 	/// <param name="largeText">True for large text (lower thresholds).</param>
 	/// <returns>The highest <see cref="AccessibilityLevel"/> the pair satisfies.</returns>
+	/// <remarks>A translucent color is rated as it looks over the background; see <see cref="ContrastRatio"/>.</remarks>
 	public AccessibilityLevel AccessibilityLevelAgainst(Color background, bool largeText = false)
 	{
 		double contrast = ContrastRatio(background);
@@ -41,14 +84,23 @@ public AccessibilityLevel AccessibilityLevelAgainst(Color background, bool large
 	}
 
 	/// <summary>
-	/// Adjusts this color's Oklab lightness (preserving hue and chroma) until it meets the requested
-	/// contrast level against a background. Returns this color unchanged if already sufficient or if
-	/// no adjustment can reach the target.
+	/// Adjusts this color until it meets the requested contrast level against a background, changing it as
+	/// little as it can.
 	/// </summary>
-	/// <param name="background">The background color.</param>
+	/// <param name="background">The background color, treated as opaque.</param>
 	/// <param name="target">The desired conformance level.</param>
 	/// <param name="largeText">True for large text (lower thresholds).</param>
-	/// <returns>An adjusted color, clamped to gamut.</returns>
+	/// <returns>An adjusted color inside the sRGB gamut, with this color's alpha.</returns>
+	/// <remarks>
+	/// The search first moves Oklab lightness, keeping hue, and keeping chroma wherever the sRGB gamut allows it:
+	/// near black and white a saturated color has no in-gamut form at its own chroma, so chroma is reduced there
+	/// rather than the channels being clipped, which would shift the hue and the luminance. If no lightness
+	/// reaches the target, the color is mixed towards black or white instead, so whenever black or white meets
+	/// the level against this background the result does too. Alpha is kept, and the contrast is measured on the
+	/// color as it looks over the background (see <see cref="ContrastRatio"/>), so a color too transparent to
+	/// reach the target even at black or white is returned unchanged; that, and an already sufficient color,
+	/// are the only cases that return this color as it is.
+	/// </remarks>
 	public Color AdjustForContrast(Color background, AccessibilityLevel target, bool largeText = false)
 	{
 		double required = RequiredContrast(target, largeText);
@@ -60,34 +112,38 @@ public Color AdjustForContrast(Color background, AccessibilityLevel target, bool
 
 		Oklab lab = ToOklab();
 		double alpha = A;
+		Color self = this;
 
 		// Try first the direction whose extreme (white or black) gives the higher contrast against
 		// this background. The two are equal near luminance 0.179, not 0.5, so on a mid-tone
 		// background darkening is usually the only way to reach the target. If the preferred
-		// direction still falls short, fall back to the other one before giving up.
-		double bgLum = background.RelativeLuminance;
+		// direction still falls short, fall back to the other one, then to mixing towards black or
+		// white, before giving up.
+		double bgLum = background.WithAlpha(1.0).RelativeLuminance;
 		bool preferLighter = (1.05 / (bgLum + 0.05)) >= ((bgLum + 0.05) / 0.05);
 
-		return Search(preferLighter) ?? Search(!preferLighter) ?? this;
+		return Search(preferLighter, LightnessCandidate)
+			?? Search(!preferLighter, LightnessCandidate)
+			?? Search(preferLighter, MixCandidate)
+			?? Search(!preferLighter, MixCandidate)
+			?? this;
 
-		Color? Search(bool goLighter)
+		Color? Search(bool goLighter, Func<bool, double, Color> candidateAt)
 		{
-			double lo = goLighter ? lab.L : 0.0;
-			double hi = goLighter ? 1.0 : lab.L;
+			// t runs from 0 (this color) to 1 (the extreme in the chosen direction), and contrast grows
+			// as t does: binary-search the smallest movement that meets the requirement.
+			Color extreme = candidateAt(goLighter, 1.0);
+			if (extreme.ContrastRatio(background) < required)
+			{
+				return null;
+			}
 
-			// Contrast increases monotonically as L moves toward the chosen extreme; binary-search
-			// the smallest movement that meets the requirement.
+			double lo = 0.0;
+			double hi = 1.0;
 			for (int i = 0; i < 30; i++)
 			{
 				double mid = (lo + hi) / 2.0;
-				Color candidate = Candidate(lab, mid);
-				bool meets = candidate.ContrastRatio(background) >= required;
-
-				// The interval always shrinks toward the end that satisfies the requirement. When
-				// lightening that is the upper bound if the midpoint already meets it; when darkening
-				// the roles swap. Both cases reduce to whether the midpoint landed on the goLighter
-				// side, so the four-way branch collapses to one comparison.
-				if (meets == goLighter)
+				if (candidateAt(goLighter, mid).ContrastRatio(background) >= required)
 				{
 					hi = mid;
 				}
@@ -97,14 +153,73 @@ public Color AdjustForContrast(Color background, AccessibilityLevel target, bool
 				}
 			}
 
-			Color result = Candidate(lab, goLighter ? hi : lo);
-			return result.ContrastRatio(background) >= required ? result : null;
+			Color result = candidateAt(goLighter, hi);
+			return result.ContrastRatio(background) >= required ? result : extreme;
 		}
 
-		Color Candidate(Oklab source, double lightness) =>
-			FromOklab(new Oklab(lightness, source.A, source.B), alpha).Clamp();
+		Color LightnessCandidate(bool goLighter, double t)
+		{
+			double end = goLighter ? 1.0 : 0.0;
+			return GamutMapped(new Oklab(lab.L + ((end - lab.L) * t), lab.A, lab.B), alpha);
+		}
+
+		Color MixCandidate(bool goLighter, double t)
+		{
+			Color end = goLighter ? new Color(1.0, 1.0, 1.0, alpha) : new Color(0.0, 0.0, 0.0, alpha);
+			return self.Clamp().Lerp(end, t).WithAlpha(alpha);
+		}
 	}
 
+	/// <summary>
+	/// Converts an Oklab color to the nearest in-gamut linear color of the same lightness and hue, reducing
+	/// chroma until it fits, as CSS Color 4 gamut-maps. Lightness at or past 0 or 1 gives black or white.
+	/// </summary>
+	/// <param name="lab">The Oklab color.</param>
+	/// <param name="alpha">The straight alpha for the result.</param>
+	/// <returns>A color with every channel in 0..1.</returns>
+	internal static Color GamutMapped(Oklab lab, double alpha)
+	{
+		const double tolerance = 1e-6;
+
+		if (lab.L >= 1.0)
+		{
+			return new Color(1.0, 1.0, 1.0, Clamp01(alpha));
+		}
+
+		if (lab.L <= 0.0)
+		{
+			return new Color(0.0, 0.0, 0.0, Clamp01(alpha));
+		}
+
+		Color direct = lab.ToColor(alpha);
+		if (IsInGamut(direct, tolerance))
+		{
+			return direct.Clamp();
+		}
+
+		double lo = 0.0;
+		double hi = 1.0;
+		for (int i = 0; i < 30; i++)
+		{
+			double mid = (lo + hi) / 2.0;
+			if (IsInGamut(new Oklab(lab.L, lab.A * mid, lab.B * mid).ToColor(alpha), tolerance))
+			{
+				lo = mid;
+			}
+			else
+			{
+				hi = mid;
+			}
+		}
+
+		return new Oklab(lab.L, lab.A * lo, lab.B * lo).ToColor(alpha).Clamp();
+	}
+
+	private static bool IsInGamut(Color color, double tolerance) =>
+		color.R >= -tolerance && color.R <= 1.0 + tolerance
+		&& color.G >= -tolerance && color.G <= 1.0 + tolerance
+		&& color.B >= -tolerance && color.B <= 1.0 + tolerance;
+
 	/// <summary>
 	/// The WCAG contrast ratio a foreground/background pair must reach to satisfy
 	/// <paramref name="level"/>.
@@ -135,7 +250,12 @@ public double DistanceTo(Color other)
 	/// <summary>Mixes this color with another in Oklab space (perceptually uniform).</summary>
 	/// <param name="other">The other color.</param>
 	/// <param name="t">The interpolation factor, 0 = this, 1 = other.</param>
-	/// <returns>The mixed color.</returns>
+	/// <returns>The mixed color, inside the sRGB gamut.</returns>
+	/// <remarks>
+	/// A straight line in Oklab between two in-gamut colors can leave the sRGB gamut, as cyan to blue does, so
+	/// the mix is gamut-mapped by reducing its chroma at the same lightness and hue. Without that, every HSL
+	/// adjustment made to the result afterwards would start from channels outside 0..1.
+	/// </remarks>
 	public Color MixOklab(Color other, double t)
 	{
 		Oklab a = ToOklab();
@@ -145,7 +265,7 @@ public Color MixOklab(Color other, double t)
 			(a.L * inv) + (b.L * t),
 			(a.A * inv) + (b.A * t),
 			(a.B * inv) + (b.B * t));
-		return FromOklab(mixed, (A * inv) + (other.A * t));
+		return GamutMapped(mixed, (A * inv) + (other.A * t));
 	}
 
 	/// <summary>Linearly interpolates this color with another in linear-RGB space.</summary>
@@ -165,7 +285,7 @@ public Color Lerp(Color other, double t)
 	/// <summary>Builds a perceptually-uniform (Oklab) gradient from this color to another.</summary>
 	/// <param name="to">The end color.</param>
 	/// <param name="steps">The number of colors to produce (at least 2).</param>
-	/// <returns>The gradient, inclusive of both endpoints.</returns>
+	/// <returns>The gradient, inclusive of both endpoints; every interior stop is inside the sRGB gamut (see <see cref="MixOklab"/>).</returns>
 	/// <exception cref="ArgumentException">Thrown when <paramref name="steps"/> is less than 2.</exception>
 	public IReadOnlyList<Color> Gradient(Color to, int steps)
 	{
diff --git a/Semantics.Color/Hsl.cs b/Semantics.Color/Hsl.cs
index be1a0053..319d4664 100644
--- a/Semantics.Color/Hsl.cs
+++ b/Semantics.Color/Hsl.cs
@@ -13,18 +13,30 @@ namespace ktsu.Semantics.Color;
 /// <param name="L">Lightness, 0..1.</param>
 public readonly record struct Hsl(double H, double S, double L)
 {
+	/// <summary>The channel spread below which a color is treated as gray, so rounding noise has no hue.</summary>
+	internal const double AchromaticTolerance = 1e-6;
+
 	/// <summary>Converts a gamma-encoded <see cref="Srgb"/> color to HSL.</summary>
 	/// <param name="srgb">The sRGB color.</param>
 	/// <returns>The HSL equivalent.</returns>
+	/// <remarks>
+	/// HSL is only defined inside the sRGB gamut, so each channel is clamped to 0..1 first. Without that an
+	/// out-of-gamut input, such as a slightly-over-white Oklab round trip, gives a saturation far above 1 that
+	/// every later HSL adjustment carries into its result. Channels within 1e-6 of each other, far below
+	/// anything an 8-bit or 16-bit channel can hold, are treated as gray.
+	/// </remarks>
 	public static Hsl FromSrgb(Srgb srgb)
 	{
+		srgb = srgb.Clamp();
 		double max = Math.Max(srgb.R, Math.Max(srgb.G, srgb.B));
 		double min = Math.Min(srgb.R, Math.Min(srgb.G, srgb.B));
 		double l = (max + min) / 2.0;
 		double h = 0.0;
 		double s = 0.0;
 
-		if (max > min)
+		// Channels a rounding error apart are gray: near white or black the saturation formula divides by
+		// almost nothing, so a difference of 1e-7 would otherwise read as full saturation.
+		if (max - min > AchromaticTolerance)
 		{
 			double d = max - min;
 			s = l > 0.5 ? d / (2.0 - max - min) : d / (max + min);
diff --git a/Semantics.Color/Hsv.cs b/Semantics.Color/Hsv.cs
index f6f14b74..ffacc20f 100644
--- a/Semantics.Color/Hsv.cs
+++ b/Semantics.Color/Hsv.cs
@@ -16,13 +16,16 @@ public readonly record struct Hsv(double H, double S, double V)
 	/// <summary>Converts a gamma-encoded <see cref="Srgb"/> color to HSV.</summary>
 	/// <param name="srgb">The sRGB color.</param>
 	/// <returns>The HSV equivalent.</returns>
+	/// <remarks>HSV is only defined inside the sRGB gamut, so each channel is clamped to 0..1 first.</remarks>
 	public static Hsv FromSrgb(Srgb srgb)
 	{
+		srgb = srgb.Clamp();
 		double max = Math.Max(srgb.R, Math.Max(srgb.G, srgb.B));
 		double min = Math.Min(srgb.R, Math.Min(srgb.G, srgb.B));
 		double d = max - min;
-		double h = d > 0.0 ? Hsl.HueDegrees(srgb, max, d) : 0.0;
-		double s = max > 0.0 ? d / max : 0.0;
+		bool chromatic = d > Hsl.AchromaticTolerance;
+		double h = chromatic ? Hsl.HueDegrees(srgb, max, d) : 0.0;
+		double s = chromatic && max > 0.0 ? d / max : 0.0;
 		return new Hsv(h, s, max);
 	}
 
diff --git a/Semantics.Color/NamedColors.cs b/Semantics.Color/NamedColors.cs
index b41537e7..c160ef6d 100644
--- a/Semantics.Color/NamedColors.cs
+++ b/Semantics.Color/NamedColors.cs
@@ -5,7 +5,11 @@ namespace ktsu.Semantics.Color;
 using System;
 using System.Collections.Generic;
 
-/// <summary>A small table of common named colors (CSS/X11 subset), as linear <see cref="Color"/>.</summary>
+/// <summary>
+/// A small table of common CSS named colors, as linear <see cref="Color"/>. Every entry has the value CSS Color
+/// Module Level 4 gives it, so a name resolves to the same color it does in a browser: <c>green</c> is CSS's
+/// <c>#008000</c>, not X11's <c>#00FF00</c>, which CSS calls <c>lime</c>.
+/// </summary>
 public static class NamedColors
 {
 	/// <summary>Opaque black (#000000).</summary>
@@ -17,8 +21,11 @@ public static class NamedColors
 	/// <summary>Opaque red (#FF0000).</summary>
 	public static Color Red => Color.FromHex("#FF0000");
 
-	/// <summary>Opaque green (#00FF00).</summary>
-	public static Color Green => Color.FromHex("#00FF00");
+	/// <summary>Opaque green (#008000), as CSS defines it. Full-intensity green is <see cref="Lime"/>.</summary>
+	public static Color Green => Color.FromHex("#008000");
+
+	/// <summary>Opaque lime (#00FF00), full-intensity green.</summary>
+	public static Color Lime => Color.FromHex("#00FF00");
 
 	/// <summary>Opaque blue (#0000FF).</summary>
 	public static Color Blue => Color.FromHex("#0000FF");
@@ -50,6 +57,7 @@ public static class NamedColors
 		["white"] = White,
 		["red"] = Red,
 		["green"] = Green,
+		["lime"] = Lime,
 		["blue"] = Blue,
 		["yellow"] = Yellow,
 		["cyan"] = Cyan,
diff --git a/Semantics.Color/README.md b/Semantics.Color/README.md
index cbb28842..1d10160c 100644
--- a/Semantics.Color/README.md
+++ b/Semantics.Color/README.md
@@ -23,11 +23,11 @@ On top of that foundation the package adds perceptual operations in the Oklab co
 - **Linear RGB as the hub**: `Color` stores linear RGBA in 0..1, and all mixing, interpolation, and luminance math happens there.
 - **Color spaces**: sRGB (`Srgb`), HSL (`Hsl`), HSV (`Hsv`), Oklab (`Oklab`), and Oklch (`Oklch`). Every color type (including `Color`) converts directly to and from every other through `From*` / `To*` methods. Each hop is routed through the nearest shared hub, so a conversion crosses the gamma boundary at most once and never takes a redundant gamma round-trip.
 - **Interop**: hex parse and format (`#RGB`, `#RRGGBB`, `#RRGGBBAA`), 8-bit byte tuples, and linear or sRGB `Vector3` / `Vector4` output (the sRGB vectors are what ImGui expects).
-- **WCAG accessibility**: relative luminance, contrast ratio (1..21), conformance rating against a background, and `AdjustForContrast` which binary-searches Oklab lightness to hit a target while preserving hue and chroma.
+- **WCAG accessibility**: relative luminance, contrast ratio (1..21), conformance rating against a background, and `AdjustForContrast` which binary-searches Oklab lightness to hit a target while preserving hue, reducing chroma only where the sRGB gamut requires it and mixing towards black or white when lightness alone cannot reach the target. A translucent foreground is measured as it looks composited over the background, as WCAG checkers do.
 - **Color vision simulation**: `Simulate(deficiency, severity)` shows a color as someone with protan, deutan, or tritan color vision sees it, from the Machado, Oliveira, and Fernandes (2009) matrices at any severity from 0 to 1.
 - **Perceptual operations**: Oklab distance (`DistanceTo`), perceptually uniform mixing (`MixOklab`), and Oklab gradients (`Gradient`), alongside plain linear `Lerp`.
 - **Adjustments**: lighten/darken, saturate/desaturate, hue offset, grayscale, and invert. HSL-based on `Color`, `Hsl`, and `Srgb`; perceptually-uniform (lightness/chroma) variants on `Oklch`.
-- **Named colors**: a CSS/X11 subset with case-insensitive lookup.
+- **Named colors**: a subset of the CSS named colors, with CSS's values (`green` is `#008000`, `lime` is `#00FF00`) and case-insensitive lookup.
 
 ## Installation
 
@@ -181,11 +181,12 @@ The canonical color: linear RGBA, each channel `double` in 0..1. A `readonly rec
 | Name | Return Type | Description |
 |------|-------------|-------------|
 | `RelativeLuminance` | `double` | WCAG luminance. |
-| `ContrastRatio(other)` | `double` | WCAG ratio, 1..21. |
+| `CompositeOver(background)` | `Color` | Source-over blend in gamma sRGB, as browsers blend. |
+| `ContrastRatio(other)` | `double` | WCAG ratio, 1..21, with a translucent color composited over `other` first. |
 | `AccessibilityLevelAgainst(background, largeText = false)` | `AccessibilityLevel` | Conformance rating. |
-| `AdjustForContrast(background, target, largeText = false)` | `Color` | Nudge lightness to meet a target level. |
+| `AdjustForContrast(background, target, largeText = false)` | `Color` | Nudge lightness (or mix towards black or white) to meet a target level. |
 | `DistanceTo(other)` | `double` | Perceptual Oklab distance. |
-| `MixOklab(other, t)` | `Color` | Perceptually uniform mix (`t = 0` returns this, `t = 1` returns other). |
+| `MixOklab(other, t)` | `Color` | Perceptually uniform mix (`t = 0` returns this, `t = 1` returns other), gamut-mapped into sRGB. |
 | `Lerp(other, t)` | `Color` | Linear-RGB interpolation. |
 | `Gradient(to, steps)` | `IReadOnlyList<Color>` | Oklab gradient, inclusive of endpoints (`steps >= 2`). |
 | `Simulate(deficiency, severity)` | `Color` | The color as seen with a color vision deficiency (Machado et al. 2009), severity 0..1. |
diff --git a/Semantics.Color/Srgb.cs b/Semantics.Color/Srgb.cs
index 542d4a8e..559ebdd5 100644
--- a/Semantics.Color/Srgb.cs
+++ b/Semantics.Color/Srgb.cs
@@ -78,6 +78,10 @@ public static Srgb FromLinear(Color color) =>
 	/// <returns>The inverted color.</returns>
 	public Srgb Invert() => new(1.0 - R, 1.0 - G, 1.0 - B);
 
+	/// <summary>Returns a copy with every channel clamped to the 0..1 range.</summary>
+	/// <returns>The clamped color.</returns>
+	public Srgb Clamp() => new(Color.Clamp01(R), Color.Clamp01(G), Color.Clamp01(B));
+
 	// Cylindrical adjustments. sRGB has no saturation/lightness/hue axes of its own, so these route
 	// through HSL (a within-family hop, no gamma round-trip) and return sRGB. Same semantics as the
 	// HSL operations of the same name.
diff --git a/Semantics.Test/Colors/ColorGamutAndAlphaTests.cs b/Semantics.Test/Colors/ColorGamutAndAlphaTests.cs
new file mode 100644
index 00000000..557d0ccb
--- /dev/null
+++ b/Semantics.Test/Colors/ColorGamutAndAlphaTests.cs
@@ -0,0 +1,207 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Test.Colors;
+
+using System.Collections.Generic;
+
+using ktsu.Semantics.Color;
+
+/// <summary>
+/// Tests for named colors matching CSS (#449), contrast seeing alpha (#393), contrast adjustment reaching the
+/// target for saturated colors (#351), and Oklab results staying in gamut for later HSL work (#355).
+/// </summary>
+[TestClass]
+public class ColorGamutAndAlphaTests
+{
+	private static readonly Color White = NamedColors.White;
+
+	// CSS Color Module Level 4, section 6.1, for every name the table holds.
+	private static readonly Dictionary<string, string> CssValues = new()
+	{
+		["black"] = "#000000",
+		["white"] = "#FFFFFF",
+		["red"] = "#FF0000",
+		["green"] = "#008000",
+		["lime"] = "#00FF00",
+		["blue"] = "#0000FF",
+		["yellow"] = "#FFFF00",
+		["cyan"] = "#00FFFF",
+		["magenta"] = "#FF00FF",
+		["gray"] = "#808080",
+		["grey"] = "#808080",
+		["orange"] = "#FFA500",
+		["purple"] = "#800080",
+	};
+
+	[TestMethod]
+	public void NamedColors_MatchCss()
+	{
+		foreach (KeyValuePair<string, string> entry in CssValues)
+		{
+			Assert.IsTrue(NamedColors.TryGet(entry.Key, out Color color), entry.Key);
+			Assert.AreEqual(entry.Value, color.ToHex(), entry.Key);
+		}
+
+		Assert.AreEqual("#008000", NamedColors.Green.ToHex());
+		Assert.AreEqual("#00FF00", NamedColors.Lime.ToHex());
+	}
+
+	[TestMethod]
+	public void NamedColors_EveryOpaqueEntryIsPinned()
+	{
+		foreach (string name in NamedColors.All.Keys)
+		{
+			Assert.IsTrue(name == "transparent" || CssValues.ContainsKey(name), $"'{name}' has no CSS value in this test.");
+		}
+	}
+
+	[TestMethod]
+	public void ContrastRatio_OfTransparentIsOne()
+	{
+		Assert.AreEqual(1.0, NamedColors.Transparent.ContrastRatio(White), 1e-9);
+		Assert.AreEqual(AccessibilityLevel.Fail, NamedColors.Transparent.AccessibilityLevelAgainst(White));
+	}
+
+	[TestMethod]
+	public void ContrastRatio_OfAFaintColorIsMeasuredAsBlended()
+	{
+		Color faint = Color.FromLinear(0, 0, 0, 0.05);
+
+		Assert.AreEqual(AccessibilityLevel.Fail, faint.AccessibilityLevelAgainst(White));
+		Assert.IsLessThan(1.2, faint.ContrastRatio(White));
+	}
+
+	[TestMethod]
+	public void ContrastRatio_OfOpaqueColorsIsUnchanged()
+	{
+		Assert.AreEqual(21.0, NamedColors.Black.ContrastRatio(White), 1e-9);
+		Assert.AreEqual(21.0, White.ContrastRatio(NamedColors.Black), 1e-9);
+		Assert.AreEqual(NamedColors.Gray.ContrastRatio(White), White.ContrastRatio(NamedColors.Gray), 1e-12);
+	}
+
+	[TestMethod]
+	public void CompositeOver_BlendsInSrgbLikeABrowser()
+	{
+		Color halfBlack = Color.FromLinear(0, 0, 0, 0.5);
+		Color blended = halfBlack.CompositeOver(White);
+
+		// 50% black over white is sRGB 0.5 in every channel, #808080 rounded as browsers render it.
+		Assert.AreEqual(0.5, blended.ToSrgb().R, 1e-9);
+		Assert.AreEqual(1.0, blended.A, 1e-12);
+		Assert.AreEqual(White, NamedColors.Transparent.CompositeOver(White));
+	}
+
+	[TestMethod]
+	public void AdjustForContrast_FixesATranslucentColorWhenItCan()
+	{
+		Color halfGray = Color.FromHex("#888888").WithAlpha(0.6);
+		Color adjusted = halfGray.AdjustForContrast(White, AccessibilityLevel.AA);
+
+		Assert.AreEqual(0.6, adjusted.A, 1e-12);
+		Assert.IsGreaterThanOrEqualTo(4.5, adjusted.ContrastRatio(White));
+	}
+
+	[TestMethod]
+	public void AdjustForContrast_ReturnsATooFaintColorUnchanged()
+	{
+		Color faint = Color.FromLinear(0, 0, 0, 0.05);
+		Assert.AreEqual(faint, faint.AdjustForContrast(White, AccessibilityLevel.AAA));
+	}
+
+	[TestMethod]
+	[DataRow("#0000FF", "#777777", AccessibilityLevel.AA)]
+	[DataRow("#8000FF", "#777777", AccessibilityLevel.AA)]
+	[DataRow("#0000AA", "#777777", AccessibilityLevel.AA)]
+	[DataRow("#FF0000", "#0000FF", AccessibilityLevel.AAA)]
+	[DataRow("#FF00FF", "#0000FF", AccessibilityLevel.AAA)]
+	public void AdjustForContrast_ReachesTheTargetForSaturatedColors(string foreground, string background, AccessibilityLevel level)
+	{
+		Color fg = Color.FromHex(foreground);
+		Color bg = Color.FromHex(background);
+		double required = level == AccessibilityLevel.AAA ? 7.0 : 4.5;
+
+		Color adjusted = fg.AdjustForContrast(bg, level);
+
+		Assert.IsGreaterThanOrEqualTo(required, adjusted.ContrastRatio(bg), $"{foreground} on {background} gave {adjusted.ToHex()}");
+		AssertInGamut(adjusted);
+	}
+
+	[TestMethod]
+	public void AdjustForContrast_KeepsTheHueOfABlueItDarkens()
+	{
+		Color adjusted = Color.FromHex("#0000FF").AdjustForContrast(Color.FromHex("#777777"), AccessibilityLevel.AA);
+		(byte r, byte g, byte b, byte _) = adjusted.ToBytes();
+
+		Assert.IsGreaterThan(r, b, adjusted.ToHex());
+		Assert.IsGreaterThan(g, b, adjusted.ToHex());
+	}
+
+	[TestMethod]
+	public void HslAdjustments_AfterAnOklabRoundTripOfWhite()
+	{
+		Color roundTripped = Color.FromOklab(White.ToOklab());
+
+		Assert.AreEqual(0.0, roundTripped.ToHsl().S, 1e-9);
+		Assert.AreEqual("#7F7F7F", roundTripped.DarkenBy(0.5).ToHex());
+		Assert.AreEqual("#7F7F7F", White.MixOklab(White, 0.5).DarkenBy(0.5).ToHex());
+	}
+
+	[TestMethod]
+	public void LightenBy_OfAnOutOfGamutOklchGreenIsNotBlack()
+	{
+		Color lightened = Color.FromOklch(new Oklch(0.7, 0.3, 150)).LightenBy(0.1);
+		Assert.AreNotEqual("#000000", lightened.ToHex());
+	}
+
+	[TestMethod]
+	public void MixOklabAndGradient_StayInGamut()
+	{
+		Color[] primaries =
+		[
+			NamedColors.Black, NamedColors.White, NamedColors.Red, NamedColors.Lime,
+			NamedColors.Blue, NamedColors.Yellow, NamedColors.Cyan, NamedColors.Magenta,
+		];
+
+		foreach (Color a in primaries)
+		{
+			foreach (Color b in primaries)
+			{
+				Color mixed = a.MixOklab(b, 0.5);
+				AssertInGamut(mixed);
+				Hsl hsl = mixed.ToHsl();
+				Assert.IsTrue(hsl.S is >= 0.0 and <= 1.0 && hsl.L is >= 0.0 and <= 1.0, $"{a.ToHex()} + {b.ToHex()} gave {hsl}");
+
+				foreach (Color stop in a.Gradient(b, 5))
+				{
+					AssertInGamut(stop);
+				}
+			}
+		}
+	}
+
+	[TestMethod]
+	public void CyanMixedWithBlue_DesaturatesRatherThanDarkens()
+	{
+		Color mixed = NamedColors.Cyan.MixOklab(NamedColors.Blue, 0.5);
+		Assert.AreNotEqual("#292929", mixed.ToGrayscale().ToHex());
+		double saturation = mixed.ToHsl().S;
+		Assert.AreEqual(System.Math.Max(0.0, saturation - 0.3), mixed.DesaturateBy(0.3).ToHsl().S, 0.02);
+	}
+
+	[TestMethod]
+	public void HslAndHsv_OfOutOfGamutInputAreInRange()
+	{
+		Srgb over = new(1.0000001, 0.99999998, 0.9999997);
+		Assert.AreEqual(0.0, Hsl.FromSrgb(over).S, 1e-6);
+
+		Hsv hsv = Hsv.FromSrgb(new Srgb(-0.2, 0.5, 1.3));
+		Assert.IsTrue(hsv.S is >= 0.0 and <= 1.0 && hsv.V is >= 0.0 and <= 1.0, hsv.ToString());
+	}
+
+	private static void AssertInGamut(Color color)
+	{
+		Assert.IsTrue(
+			color.R is >= 0.0 and <= 1.0 && color.G is >= 0.0 and <= 1.0 && color.B is >= 0.0 and <= 1.0,
+			$"{color} is out of gamut");
+	}
+}

From 5f727f02d01b35e658f0e72125cb164ad43926bb Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 10:49:36 +0000
Subject: [PATCH 3/8] [patch] Quantities: constants per field, decimal logs,
 positive guards, division by zero, scaled vector lengths, bounded roots

- domains.json: AbsoluteZeroInCelsius is -273.15, WaterIonProduct is
  1e-14 and MolarVolumeSTP is in m3/mol; mu0/epsilon0 no longer claim
  to be exact (#386).
- Each physical constant is its own lazily filled field, so one that a
  storage type cannot hold throws alone, and one that would lose its
  precision throws instead of reading as zero (#392).
- Logarithmic conversions throw ArgumentOutOfRangeException for a level
  the storage type cannot hold (a linear zero with decimal or integer
  storage) and OverflowException going back, as documented (#352).
- Wavelength, Period and HalfLife keep EnsurePositive through scaling,
  narrowing and subtraction (#354).
- Every generated division throws DivideByZeroException for a zero
  divisor, including vector / scalar, cross-dimension operators and
  Normalize() of a zero vector (#480).
- Vector Length() and Distance() go through StorageMath.Hypot, scaled by
  the largest component, so int, decimal and float vectors whose squares
  overflow still have a length (#327).
- Cbrt/RootN stop for PreciseNumber instead of hanging (#457).

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 CLAUDE.md                                     |  36 +++-
 .../AudioEngineering/Decibels.cs              |  10 +-
 Semantics.Quantities/AudioEngineering/Gain.cs |   3 +-
 .../Cents.g.cs                                |   8 +-
 .../Decibels.g.cs                             |  16 +-
 .../DirectionalityIndex.g.cs                  |   8 +-
 .../PH.g.cs                                   |   8 +-
 .../Semitones.g.cs                            |   8 +-
 .../SoundIntensityLevel.g.cs                  |   8 +-
 .../SoundPowerLevel.g.cs                      |   8 +-
 .../SoundPressureLevel.g.cs                   |   8 +-
 .../PhysicalConstants.g.cs                    | 185 +++++++++++++-----
 .../Acceleration1D.g.cs                       |   2 +-
 .../Acceleration2D.g.cs                       |  21 +-
 .../Acceleration3D.g.cs                       |  21 +-
 .../Acceleration4D.g.cs                       |  21 +-
 .../AccelerationMagnitude.g.cs                |   4 +-
 .../AmountOfSubstance.g.cs                    |   8 +-
 .../Angle.g.cs                                |   4 +-
 .../AngularAcceleration1D.g.cs                |   2 +-
 .../AngularAcceleration3D.g.cs                |  21 +-
 .../AngularAccelerationMagnitude.g.cs         |   4 +-
 .../AngularDisplacement3D.g.cs                |  21 +-
 .../AngularJerk3D.g.cs                        |  19 +-
 .../AngularMomentum1D.g.cs                    |   2 +-
 .../AngularMomentum3D.g.cs                    |  21 +-
 .../AngularMomentumMagnitude.g.cs             |   2 +-
 .../AngularSpeed.g.cs                         |   4 +-
 .../AngularVelocity1D.g.cs                    |   2 +-
 .../AngularVelocity3D.g.cs                    |  21 +-
 .../Area.g.cs                                 |   2 +-
 .../Charge.g.cs                               |   2 +-
 .../ChargeMagnitude.g.cs                      |   8 +-
 .../Concentration.g.cs                        |   4 +-
 .../Current3D.g.cs                            |  19 +-
 .../CurrentMagnitude.g.cs                     |   4 +-
 .../Displacement1D.g.cs                       |   2 +-
 .../Displacement2D.g.cs                       |  21 +-
 .../Displacement3D.g.cs                       |  21 +-
 .../Displacement4D.g.cs                       |  21 +-
 .../DynamicViscosity.g.cs                     |   2 +-
 .../ElectricField2D.g.cs                      |  19 +-
 .../ElectricField3D.g.cs                      |  19 +-
 .../ElectricFlux.g.cs                         |   4 +-
 .../Energy.g.cs                               |  20 +-
 .../Entropy.g.cs                              |   4 +-
 .../Force2D.g.cs                              |  19 +-
 .../Force3D.g.cs                              |  19 +-
 .../Force4D.g.cs                              |  19 +-
 .../ForceMagnitude.g.cs                       |  10 +-
 .../GravitationalField3D.g.cs                 |  19 +-
 .../GravitationalParameter.g.cs               |   4 +-
 .../HalfLife.g.cs                             |  24 +--
 .../Jerk1D.g.cs                               |   2 +-
 .../Jerk2D.g.cs                               |  21 +-
 .../Jerk3D.g.cs                               |  21 +-
 .../Jerk4D.g.cs                               |  21 +-
 .../JerkMagnitude.g.cs                        |   4 +-
 .../Length.g.cs                               |   4 +-
 .../LuminousFlux.g.cs                         |   4 +-
 .../LuminousIntensity.g.cs                    |   4 +-
 .../MagneticFlux.g.cs                         |  10 +-
 .../MagneticFluxDensity3D.g.cs                |  19 +-
 .../Mass.g.cs                                 |  12 +-
 .../Momentum1D.g.cs                           |   2 +-
 .../Momentum2D.g.cs                           |  21 +-
 .../Momentum3D.g.cs                           |  21 +-
 .../Momentum4D.g.cs                           |  21 +-
 .../MomentumMagnitude.g.cs                    |   8 +-
 .../Period.g.cs                               |  24 +--
 .../Position3D.g.cs                           |  19 +-
 .../Power.g.cs                                |  16 +-
 .../Ratio.g.cs                                |   8 +-
 .../SignedAngle.g.cs                          |   2 +-
 .../SignedRatio.g.cs                          |   2 +-
 .../Snap2D.g.cs                               |  19 +-
 .../Snap3D.g.cs                               |  19 +-
 .../Snap4D.g.cs                               |  19 +-
 .../SpecificAngularMomentum3D.g.cs            |  19 +-
 .../Speed.g.cs                                |   8 +-
 .../ThrustVector.g.cs                         |  19 +-
 .../Torque3D.g.cs                             |  19 +-
 .../Translation3D.g.cs                        |  19 +-
 .../Velocity1D.g.cs                           |   2 +-
 .../Velocity2D.g.cs                           |  21 +-
 .../Velocity3D.g.cs                           |  21 +-
 .../Velocity4D.g.cs                           |  21 +-
 .../Voltage.g.cs                              |   4 +-
 .../VoltageMagnitude.g.cs                     |  12 +-
 .../Volume.g.cs                               |   8 +-
 .../Wavelength.g.cs                           |  24 +--
 .../WeightVector.g.cs                         |  19 +-
 .../WindVelocity3D.g.cs                       |  19 +-
 Semantics.Quantities/LogarithmicStorage.cs    |  85 ++++++++
 Semantics.Quantities/StorageLiteral.cs        |  63 ++++++
 Semantics.Quantities/StorageMath.cs           | 124 ++++++++++++
 .../Generators/LogarithmicScalesGenerator.cs  |   8 +-
 .../Generators/PhysicalConstantsGenerator.cs  |  27 +--
 .../Generators/QuantitiesGenerator.cs         |  93 ++++++---
 .../Metadata/domains.json                     |  14 +-
 .../Quantities/PhysicsBugfixTests.cs          | 135 +++++++++++++
 .../StorageMathPreciseAndVectorTests.cs       |  88 +++++++++
 102 files changed, 1387 insertions(+), 600 deletions(-)
 create mode 100644 Semantics.Quantities/LogarithmicStorage.cs
 create mode 100644 Semantics.Test/Quantities/PhysicsBugfixTests.cs
 create mode 100644 Semantics.Test/Quantities/StorageMathPreciseAndVectorTests.cs

diff --git a/CLAUDE.md b/CLAUDE.md
index 186a2f19..e381cf09 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -298,12 +298,21 @@ PhysicalConstants.Generic.PlanckConstant<T>()
 PhysicalConstants.Generic.DegreesPerRadian<T>()
 ```
 
-Each constant is emitted as `T.Parse(literal, NumberStyles.Float, CultureInfo.InvariantCulture)`
-into a private `Values<T>` holder nested in its domain class, so the literal is parsed once per
-closed generic type and the package needs no arbitrary-precision dependency. `NumberStyles.Float`
-is mandatory, not incidental: several literals are in exponent form (`6.62607015e-34`, `20e-6`),
-and the `Parse(string, IFormatProvider)` overload resolves to `NumberStyles.Number` for some
-numeric types, which rejects an exponent.
+Each constant is emitted as a property over its own lazily filled field in a private `Values<T>`
+holder nested in its domain class, filled by `StorageLiteral.Constant<T>(literal, name)` the first
+time it is read, so the literal is parsed once per constant and closed generic type and the package
+needs no arbitrary-precision dependency. The literal is parsed with `NumberStyles.Float`, which is
+mandatory, not incidental: several literals are in exponent form (`6.62607015e-34`, `20e-6`), and the
+`Parse(string, IFormatProvider)` overload resolves to `NumberStyles.Number` for some numeric types,
+which rejects an exponent.
+
+**Keep constants out of a shared initializer**, for the same reason as conversion factors below
+(#392): with every constant of a domain in one static initializer, one literal `int` could not hold
+made every constant of that domain throw `TypeInitializationException`, so `PH<int>.Neutral` failed
+because `GasConstant` has a fraction. Now a constant `T` cannot hold throws from its own accessor:
+`OverflowException` when it is too large, and `ArithmeticException` when `T` keeps less than about six
+significant digits of it (`StandardGravity<int>` truncating to 9, `PlanckConstant<decimal>` rounding
+to zero). A whole number in range, such as `SpeedOfLight<long>()`, works.
 
 ### Conversion factors and square roots at the storage type's precision
 
@@ -347,13 +356,20 @@ converted with the 15 significant digits that conversion keeps.
   written outside the library needs nothing new. They are not named `Get…`, because CA1721 rejects
   a `GetToBaseFactor` method next to the `ToBaseFactor` property.
 
-Vector `Length()` and `Distance()` call `StorageMath.Sqrt`. The binary floating point and integer
-primitives take the `Math.Sqrt` round trip the generated code always inlined, so their results are
-unchanged. Any other type is seeded from that root and refined with Newton steps in its own
+Vector `Length()` and `Distance()` call `StorageMath.Hypot`, never a raw sum of squares (#327): the
+two-component form is the public `Hypot`, and three and four components go through internal overloads
+of it. A fractional type is scaled by its largest component first, so `Position3D<decimal>` at 1e15 m
+still has a length, and the primitives take `double.Hypot`, so an `int` component of 65536 no longer
+squares to zero. `Normalize()` of a zero-length vector throws `DivideByZeroException`, as every
+generated division by zero does (#480). The square root itself is `StorageMath.Sqrt`: the binary
+floating point and integer primitives take the `Math.Sqrt` round trip. Any other type is seeded from that root and refined with Newton steps in its own
 arithmetic, so a `decimal` length has 28 significant digits. A value a `double` cannot hold, such as a
 `BigInteger` of 2^2048, is scaled by powers of four into [1, 4) for the seed, and the root is scaled
 back by the matching power of two. A root that does not settle throws `ArithmeticException` rather
-than returning an estimate. The logarithmic scales and the hand-written audio types still compute
+than returning an estimate. A type with no fixed precision, such as `PreciseNumber`, never settles,
+because its products keep every digit and each Newton estimate doubles in length; `Cbrt` and `RootN`
+stop it once a step moves the estimate by less than one part in 10^60 (#457), a tolerance a
+fixed-precision type rounds to zero and so never sees. The logarithmic scales and the hand-written audio types still compute
 through `double`, and as of #235 every generated conversion says so in its own XML `<remarks>`
 rather than only here — the method tooltip is where a `decimal` or `PreciseNumber` consumer spends
 the precision, so that is where the cost is stated. `SourceGeneratorTests` counts the remarks
diff --git a/Semantics.Quantities/AudioEngineering/Decibels.cs b/Semantics.Quantities/AudioEngineering/Decibels.cs
index 6a5f249a..a471dcaa 100644
--- a/Semantics.Quantities/AudioEngineering/Decibels.cs
+++ b/Semantics.Quantities/AudioEngineering/Decibels.cs
@@ -19,21 +19,23 @@ public readonly partial record struct Decibels<T>
 	/// Creates a level from a raw linear amplitude ratio using <c>dB = 20·log10(ratio)</c>.
 	/// </summary>
 	/// <param name="amplitude">The linear amplitude ratio.</param>
-	/// <returns>A new <see cref="Decibels{T}"/>. An amplitude of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="Decibels{T}"/>. An amplitude of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the level, as for an amplitude of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static Decibels<T> FromAmplitude(T amplitude)
 	{
 		double linear = double.CreateChecked(amplitude);
-		return new(T.CreateChecked(20.0 * Math.Log10(linear)));
+		return new(LogarithmicStorage.FromLinear<T>(20.0 * Math.Log10(linear), nameof(amplitude)));
 	}
 
 	/// <summary>
 	/// Creates a level from a raw linear power ratio using <c>dB = 10·log10(ratio)</c>.
 	/// </summary>
 	/// <param name="power">The linear power ratio.</param>
-	/// <returns>A new <see cref="Decibels{T}"/>. A power of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="Decibels{T}"/>. A power of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the level, as for a power of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static Decibels<T> FromPower(T power)
 	{
 		double linear = double.CreateChecked(power);
-		return new(T.CreateChecked(10.0 * Math.Log10(linear)));
+		return new(LogarithmicStorage.FromLinear<T>(10.0 * Math.Log10(linear), nameof(power)));
 	}
 }
diff --git a/Semantics.Quantities/AudioEngineering/Gain.cs b/Semantics.Quantities/AudioEngineering/Gain.cs
index ebb54aec..43ab322a 100644
--- a/Semantics.Quantities/AudioEngineering/Gain.cs
+++ b/Semantics.Quantities/AudioEngineering/Gain.cs
@@ -34,7 +34,8 @@ public readonly partial record struct Gain<T>
 	/// <summary>
 	/// Converts this gain to a level in decibels using the amplitude convention <c>dB = 20·log10(gain)</c>.
 	/// </summary>
-	/// <returns>The equivalent <see cref="Decibels{T}"/>. Silence maps to negative infinity.</returns>
+	/// <returns>The equivalent <see cref="Decibels{T}"/>. Silence maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the level, as for silence with <see langword="decimal"/> or integer storage.</exception>
 	public Decibels<T> ToDecibels() => Decibels<T>.FromGain(this);
 
 	/// <summary>Multiplies two gains (cascading two stages).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs
index dcae4756..8450bde3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Cents.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct Cents<T>(T Value) : IComparable<Cents<T>>
 	/// Creates an interval from a frequency ratio using cents = 1200·log2(ratio).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
-	/// <returns>A new <see cref="Cents{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="Cents{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,10 +49,11 @@ public readonly partial record struct Cents<T>(T Value) : IComparable<Cents<T>>
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static Cents<T> FromFrequencyRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
-		return new(T.CreateChecked(1200.0 * Math.Log2(linearValue)));
+		return new(LogarithmicStorage.FromLinear<T>(1200.0 * Math.Log2(linearValue), nameof(linear)));
 	}
 
 	/// <summary>
@@ -66,10 +67,11 @@ public static Cents<T> FromFrequencyRatio(Ratio<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public Ratio<T> ToFrequencyRatio()
 	{
 		double scaleValue = double.CreateChecked(Value);
-		return Ratio<T>.Create(T.CreateChecked(Math.Pow(2.0, scaleValue / 1200.0)));
+		return Ratio<T>.Create(LogarithmicStorage.ToLinear<T>(Math.Pow(2.0, scaleValue / 1200.0)));
 	}
 
 	/// <summary>Adds two values in log space (cascading two linear stages multiplies them).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs
index 126e8fa9..81c0e151 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Decibels.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct Decibels<T>(T Value) : IComparable<Decibel
 	/// Creates a level from an amplitude gain using dB = 20·log10(gain).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Gain{T}"/>.</param>
-	/// <returns>A new <see cref="Decibels{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="Decibels{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,10 +49,11 @@ public readonly partial record struct Decibels<T>(T Value) : IComparable<Decibel
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static Decibels<T> FromGain(Gain<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
-		return new(T.CreateChecked(20.0 * Math.Log10(linearValue)));
+		return new(LogarithmicStorage.FromLinear<T>(20.0 * Math.Log10(linearValue), nameof(linear)));
 	}
 
 	/// <summary>
@@ -66,17 +67,18 @@ public static Decibels<T> FromGain(Gain<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public Gain<T> ToAmplitude()
 	{
 		double scaleValue = double.CreateChecked(Value);
-		return Gain<T>.Create(T.CreateChecked(Math.Pow(10.0, scaleValue / 20.0)));
+		return Gain<T>.Create(LogarithmicStorage.ToLinear<T>(Math.Pow(10.0, scaleValue / 20.0)));
 	}
 
 	/// <summary>
 	/// Creates a level from a linear power ratio using dB = 10·log10(ratio).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
-	/// <returns>A new <see cref="Decibels{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="Decibels{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -84,10 +86,11 @@ public Gain<T> ToAmplitude()
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static Decibels<T> FromPowerRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
-		return new(T.CreateChecked(10.0 * Math.Log10(linearValue)));
+		return new(LogarithmicStorage.FromLinear<T>(10.0 * Math.Log10(linearValue), nameof(linear)));
 	}
 
 	/// <summary>
@@ -101,10 +104,11 @@ public static Decibels<T> FromPowerRatio(Ratio<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public Ratio<T> ToPower()
 	{
 		double scaleValue = double.CreateChecked(Value);
-		return Ratio<T>.Create(T.CreateChecked(Math.Pow(10.0, scaleValue / 10.0)));
+		return Ratio<T>.Create(LogarithmicStorage.ToLinear<T>(Math.Pow(10.0, scaleValue / 10.0)));
 	}
 
 	/// <summary>Adds two values in log space (cascading two linear stages multiplies them).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs
index 051f614a..d63369c2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/DirectionalityIndex.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct DirectionalityIndex<T>(T Value) : ICompara
 	/// Creates an index from the linear on-axis-to-average intensity ratio using DI = 10·log10(ratio).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
-	/// <returns>A new <see cref="DirectionalityIndex{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="DirectionalityIndex{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,10 +49,11 @@ public readonly partial record struct DirectionalityIndex<T>(T Value) : ICompara
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static DirectionalityIndex<T> FromIntensityRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
-		return new(T.CreateChecked(10.0 * Math.Log10(linearValue)));
+		return new(LogarithmicStorage.FromLinear<T>(10.0 * Math.Log10(linearValue), nameof(linear)));
 	}
 
 	/// <summary>
@@ -66,10 +67,11 @@ public static DirectionalityIndex<T> FromIntensityRatio(Ratio<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public Ratio<T> ToIntensityRatio()
 	{
 		double scaleValue = double.CreateChecked(Value);
-		return Ratio<T>.Create(T.CreateChecked(Math.Pow(10.0, scaleValue / 10.0)));
+		return Ratio<T>.Create(LogarithmicStorage.ToLinear<T>(Math.Pow(10.0, scaleValue / 10.0)));
 	}
 
 	/// <inheritdoc/>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs
index ba4dacc7..bf905936 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/PH.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct PH<T>(T Value) : IComparable<PH<T>>
 	/// Creates a pH from a hydrogen-ion concentration using pH = −log10([H⁺] in mol/L).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Concentration{T}"/>.</param>
-	/// <returns>A new <see cref="PH{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="PH{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,11 +49,12 @@ public readonly partial record struct PH<T>(T Value) : IComparable<PH<T>>
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static PH<T> FromHydrogenConcentration(Concentration<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
 		double reference = 1000.0;
-		return new(T.CreateChecked(-1.0 * Math.Log10(linearValue / reference)));
+		return new(LogarithmicStorage.FromLinear<T>(-1.0 * Math.Log10(linearValue / reference), nameof(linear)));
 	}
 
 	/// <summary>
@@ -67,11 +68,12 @@ public static PH<T> FromHydrogenConcentration(Concentration<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public Concentration<T> ToHydrogenConcentration()
 	{
 		double scaleValue = double.CreateChecked(Value);
 		double reference = 1000.0;
-		return Concentration<T>.Create(T.CreateChecked(reference * Math.Pow(10.0, scaleValue / -1.0)));
+		return Concentration<T>.Create(LogarithmicStorage.ToLinear<T>(reference * Math.Pow(10.0, scaleValue / -1.0)));
 	}
 
 	/// <inheritdoc/>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs
index b39fc7ce..1b082e3d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/Semitones.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct Semitones<T>(T Value) : IComparable<Semito
 	/// Creates an interval from a frequency ratio using semitones = 12·log2(ratio).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="Ratio{T}"/>.</param>
-	/// <returns>A new <see cref="Semitones{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="Semitones{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,10 +49,11 @@ public readonly partial record struct Semitones<T>(T Value) : IComparable<Semito
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static Semitones<T> FromFrequencyRatio(Ratio<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
-		return new(T.CreateChecked(12.0 * Math.Log2(linearValue)));
+		return new(LogarithmicStorage.FromLinear<T>(12.0 * Math.Log2(linearValue), nameof(linear)));
 	}
 
 	/// <summary>
@@ -66,10 +67,11 @@ public static Semitones<T> FromFrequencyRatio(Ratio<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public Ratio<T> ToFrequencyRatio()
 	{
 		double scaleValue = double.CreateChecked(Value);
-		return Ratio<T>.Create(T.CreateChecked(Math.Pow(2.0, scaleValue / 12.0)));
+		return Ratio<T>.Create(LogarithmicStorage.ToLinear<T>(Math.Pow(2.0, scaleValue / 12.0)));
 	}
 
 	/// <summary>Adds two values in log space (cascading two linear stages multiplies them).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs
index ef12bdca..3b714d5c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundIntensityLevel.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct SoundIntensityLevel<T>(T Value) : ICompara
 	/// Creates a level from a linear sound intensity using SIL = 10·log10(I / I₀).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="SoundIntensity{T}"/>.</param>
-	/// <returns>A new <see cref="SoundIntensityLevel{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="SoundIntensityLevel{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,11 +49,12 @@ public readonly partial record struct SoundIntensityLevel<T>(T Value) : ICompara
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static SoundIntensityLevel<T> FromSoundIntensity(SoundIntensity<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
 		double reference = PhysicalConstants.Generic.ReferenceSoundIntensity<double>();
-		return new(T.CreateChecked(10.0 * Math.Log10(linearValue / reference)));
+		return new(LogarithmicStorage.FromLinear<T>(10.0 * Math.Log10(linearValue / reference), nameof(linear)));
 	}
 
 	/// <summary>
@@ -67,11 +68,12 @@ public static SoundIntensityLevel<T> FromSoundIntensity(SoundIntensity<T> linear
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public SoundIntensity<T> ToSoundIntensity()
 	{
 		double scaleValue = double.CreateChecked(Value);
 		double reference = PhysicalConstants.Generic.ReferenceSoundIntensity<double>();
-		return SoundIntensity<T>.Create(T.CreateChecked(reference * Math.Pow(10.0, scaleValue / 10.0)));
+		return SoundIntensity<T>.Create(LogarithmicStorage.ToLinear<T>(reference * Math.Pow(10.0, scaleValue / 10.0)));
 	}
 
 	/// <summary>Adds two values in log space (cascading two linear stages multiplies them).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs
index be113e4a..e1ffdd58 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPowerLevel.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct SoundPowerLevel<T>(T Value) : IComparable<
 	/// Creates a level from a linear sound power using SWL = 10·log10(P / P₀).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="SoundPower{T}"/>.</param>
-	/// <returns>A new <see cref="SoundPowerLevel{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="SoundPowerLevel{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,11 +49,12 @@ public readonly partial record struct SoundPowerLevel<T>(T Value) : IComparable<
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static SoundPowerLevel<T> FromSoundPower(SoundPower<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
 		double reference = PhysicalConstants.Generic.ReferenceSoundPower<double>();
-		return new(T.CreateChecked(10.0 * Math.Log10(linearValue / reference)));
+		return new(LogarithmicStorage.FromLinear<T>(10.0 * Math.Log10(linearValue / reference), nameof(linear)));
 	}
 
 	/// <summary>
@@ -67,11 +68,12 @@ public static SoundPowerLevel<T> FromSoundPower(SoundPower<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public SoundPower<T> ToSoundPower()
 	{
 		double scaleValue = double.CreateChecked(Value);
 		double reference = PhysicalConstants.Generic.ReferenceSoundPower<double>();
-		return SoundPower<T>.Create(T.CreateChecked(reference * Math.Pow(10.0, scaleValue / 10.0)));
+		return SoundPower<T>.Create(LogarithmicStorage.ToLinear<T>(reference * Math.Pow(10.0, scaleValue / 10.0)));
 	}
 
 	/// <summary>Adds two values in log space (cascading two linear stages multiplies them).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs
index e47b47c6..4012a8ee 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.LogarithmicScalesGenerator/SoundPressureLevel.g.cs
@@ -41,7 +41,7 @@ public readonly partial record struct SoundPressureLevel<T>(T Value) : IComparab
 	/// Creates a level from a linear sound pressure using SPL = 20·log10(p / p₀).
 	/// </summary>
 	/// <param name="linear">The linear <see cref="SoundPressure{T}"/>.</param>
-	/// <returns>A new <see cref="SoundPressureLevel{T}"/>. A linear value of zero maps to negative infinity.</returns>
+	/// <returns>A new <see cref="SoundPressureLevel{T}"/>. A linear value of zero maps to negative infinity where <typeparamref name="T"/> can hold it.</returns>
 	/// <remarks>
 	/// Computes in <see langword="double"/> whatever <typeparamref name="T"/> is: the value is
 	/// converted to <see langword="double"/>, the logarithm or power is taken there, and the
@@ -49,11 +49,12 @@ public readonly partial record struct SoundPressureLevel<T>(T Value) : IComparab
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="ArgumentOutOfRangeException"><typeparamref name="T"/> cannot hold the result, as for a linear value of zero with <see langword="decimal"/> or integer storage.</exception>
 	public static SoundPressureLevel<T> FromSoundPressure(SoundPressure<T> linear)
 	{
 		double linearValue = double.CreateChecked(linear.Value);
 		double reference = PhysicalConstants.Generic.ReferenceSoundPressure<double>();
-		return new(T.CreateChecked(20.0 * Math.Log10(linearValue / reference)));
+		return new(LogarithmicStorage.FromLinear<T>(20.0 * Math.Log10(linearValue / reference), nameof(linear)));
 	}
 
 	/// <summary>
@@ -67,11 +68,12 @@ public static SoundPressureLevel<T> FromSoundPressure(SoundPressure<T> linear)
 	/// <see langword="decimal"/>, or <c>PreciseNumber</c> — therefore keeps about fifteen
 	/// significant digits across this conversion, rather than the precision it is capable of.
 	/// </remarks>
+	/// <exception cref="OverflowException"><typeparamref name="T"/> cannot hold the linear value of a level this high.</exception>
 	public SoundPressure<T> ToSoundPressure()
 	{
 		double scaleValue = double.CreateChecked(Value);
 		double reference = PhysicalConstants.Generic.ReferenceSoundPressure<double>();
-		return SoundPressure<T>.Create(T.CreateChecked(reference * Math.Pow(10.0, scaleValue / 20.0)));
+		return SoundPressure<T>.Create(LogarithmicStorage.ToLinear<T>(reference * Math.Pow(10.0, scaleValue / 20.0)));
 	}
 
 	/// <summary>Adds two values in log space (cascading two linear stages multiplies them).</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs
index 5d01a603..f6c122a3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.PhysicalConstantsGenerator/PhysicalConstants.g.cs
@@ -3,7 +3,6 @@
 
 namespace ktsu.Semantics.Quantities;
 
-using System.Globalization;
 using System.Numerics;
 
 /// <summary>
@@ -36,16 +35,28 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Reference sound intensity: 1 × 10⁻¹² W/m² (threshold of hearing)</summary>
-			internal static readonly T ReferenceSoundIntensity = T.Parse("1e-12", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T ReferenceSoundIntensity => cachedReferenceSoundIntensity ??= StorageLiteral.Constant<T>("1e-12", "ReferenceSoundIntensity");
+
+			/// <summary>ReferenceSoundIntensity once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedReferenceSoundIntensity;
 
 			/// <summary>Reference sound power: 1 × 10⁻¹² W</summary>
-			internal static readonly T ReferenceSoundPower = T.Parse("1e-12", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T ReferenceSoundPower => cachedReferenceSoundPower ??= StorageLiteral.Constant<T>("1e-12", "ReferenceSoundPower");
+
+			/// <summary>ReferenceSoundPower once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedReferenceSoundPower;
 
 			/// <summary>Reference sound pressure: 20 × 10⁻⁶ Pa (threshold of hearing)</summary>
-			internal static readonly T ReferenceSoundPressure = T.Parse("20e-6", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T ReferenceSoundPressure => cachedReferenceSoundPressure ??= StorageLiteral.Constant<T>("20e-6", "ReferenceSoundPressure");
+
+			/// <summary>ReferenceSoundPressure once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedReferenceSoundPressure;
 
 			/// <summary>Sabine reverberation constant: 0.161 s/m</summary>
-			internal static readonly T SabineConstant = T.Parse("0.161", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T SabineConstant => cachedSabineConstant ??= StorageLiteral.Constant<T>("0.161", "SabineConstant");
+
+			/// <summary>SabineConstant once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedSabineConstant;
 		}
 	}
 
@@ -70,13 +81,22 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Degrees per radian: 180/π ≈ 57.29577951308232 (correctly rounded to 150 significant digits)</summary>
-			internal static readonly T DegreesPerRadian = T.Parse("57.2957795130823208767981548141051703324054724665643215491602438612028471483215526324409689958511109441862233816328648932814482646012483150360682678634", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T DegreesPerRadian => cachedDegreesPerRadian ??= StorageLiteral.Constant<T>("57.2957795130823208767981548141051703324054724665643215491602438612028471483215526324409689958511109441862233816328648932814482646012483150360682678634", "DegreesPerRadian");
+
+			/// <summary>DegreesPerRadian once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedDegreesPerRadian;
 
 			/// <summary>Radians per degree: π/180 ≈ 0.017453292519943295 (correctly rounded to 150 significant digits)</summary>
-			internal static readonly T RadiansPerDegree = T.Parse("0.0174532925199432957692369076848861271344287188854172545609719144017100911460344944368224156963450948221230449250737905924838546922752810123984742189340", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T RadiansPerDegree => cachedRadiansPerDegree ??= StorageLiteral.Constant<T>("0.0174532925199432957692369076848861271344287188854172545609719144017100911460344944368224156963450948221230449250737905924838546922752810123984742189340", "RadiansPerDegree");
+
+			/// <summary>RadiansPerDegree once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedRadiansPerDegree;
 
 			/// <summary>2π, a full rotation in radians: 6.283185307179586 (correctly rounded to 150 significant digits)</summary>
-			internal static readonly T TwoPi = T.Parse("6.28318530717958647692528676655900576839433879875021164194988918461563281257241799725606965068423413596429617302656461329418768921910116446345071881626", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T TwoPi => cachedTwoPi ??= StorageLiteral.Constant<T>("6.28318530717958647692528676655900576839433879875021164194988918461563281257241799725606965068423413596429617302656461329418768921910116446345071881626", "TwoPi");
+
+			/// <summary>TwoPi once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedTwoPi;
 		}
 	}
 
@@ -91,7 +111,7 @@ public static class Chemistry
 		/// <summary>Natural logarithm of 2: 0.6931471805599453</summary>
 		public static T Ln2<T>()  where T : struct, INumber<T> => Values<T>.Ln2;
 
-		/// <summary>Molar volume of ideal gas at STP: 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)</summary>
+		/// <summary>Molar volume of ideal gas at STP: 0.022413969545014137 m³/mol, or 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)</summary>
 		public static T MolarVolumeSTP<T>()  where T : struct, INumber<T> => Values<T>.MolarVolumeSTP;
 
 		/// <summary>Neutral pH value at 25°C: 7.0</summary>
@@ -107,19 +127,34 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Gas constant: 8.31446261815324 J/(mol·K) (exact, derived from Avogadro and Boltzmann constants)</summary>
-			internal static readonly T GasConstant = T.Parse("8.31446261815324", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T GasConstant => cachedGasConstant ??= StorageLiteral.Constant<T>("8.31446261815324", "GasConstant");
+
+			/// <summary>GasConstant once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedGasConstant;
 
 			/// <summary>Natural logarithm of 2: 0.6931471805599453</summary>
-			internal static readonly T Ln2 = T.Parse("0.6931471805599453094172321214581765680755001343602552541206800094933936219696947156058633269964186875420014810205706857336855202357581305570326707", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T Ln2 => cachedLn2 ??= StorageLiteral.Constant<T>("0.6931471805599453094172321214581765680755001343602552541206800094933936219696947156058633269964186875420014810205706857336855202357581305570326707", "Ln2");
 
-			/// <summary>Molar volume of ideal gas at STP: 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)</summary>
-			internal static readonly T MolarVolumeSTP = T.Parse("22.413969545014137", NumberStyles.Float, CultureInfo.InvariantCulture);
+			/// <summary>Ln2 once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedLn2;
+
+			/// <summary>Molar volume of ideal gas at STP: 0.022413969545014137 m³/mol, or 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)</summary>
+			internal static T MolarVolumeSTP => cachedMolarVolumeSTP ??= StorageLiteral.Constant<T>("0.022413969545014137", "MolarVolumeSTP");
+
+			/// <summary>MolarVolumeSTP once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedMolarVolumeSTP;
 
 			/// <summary>Neutral pH value at 25°C: 7.0</summary>
-			internal static readonly T NeutralPH = T.Parse("7.0", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T NeutralPH => cachedNeutralPH ??= StorageLiteral.Constant<T>("7.0", "NeutralPH");
+
+			/// <summary>NeutralPH once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedNeutralPH;
 
 			/// <summary>Water ion product (Kw) at 25°C: 1.0 × 10⁻¹⁴ (pKw = 14.0)</summary>
-			internal static readonly T WaterIonProduct = T.Parse("14.0", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T WaterIonProduct => cachedWaterIonProduct ??= StorageLiteral.Constant<T>("1.0e-14", "WaterIonProduct");
+
+			/// <summary>WaterIonProduct once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedWaterIonProduct;
 		}
 	}
 
@@ -141,10 +176,16 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Standard atmospheric pressure: 101,325 Pa (exact by definition)</summary>
-			internal static readonly T StandardAtmosphericPressure = T.Parse("101325", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T StandardAtmosphericPressure => cachedStandardAtmosphericPressure ??= StorageLiteral.Constant<T>("101325", "StandardAtmosphericPressure");
+
+			/// <summary>StandardAtmosphericPressure once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedStandardAtmosphericPressure;
 
 			/// <summary>Standard gravitational acceleration: 9.80665 m/s² (exact by definition)</summary>
-			internal static readonly T StandardGravity = T.Parse("9.80665", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T StandardGravity => cachedStandardGravity ??= StorageLiteral.Constant<T>("9.80665", "StandardGravity");
+
+			/// <summary>StandardGravity once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedStandardGravity;
 		}
 	}
 
@@ -166,10 +207,16 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Standard air density at 15°C and 1 atm: 1.225 kg/m³ (ISO 2533)</summary>
-			internal static readonly T StandardAirDensity = T.Parse("1.225", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T StandardAirDensity => cachedStandardAirDensity ??= StorageLiteral.Constant<T>("1.225", "StandardAirDensity");
+
+			/// <summary>StandardAirDensity once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedStandardAirDensity;
 
 			/// <summary>Water surface tension at 20°C: 0.0728 N/m (NIST)</summary>
-			internal static readonly T WaterSurfaceTension = T.Parse("0.0728", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T WaterSurfaceTension => cachedWaterSurfaceTension ??= StorageLiteral.Constant<T>("0.0728", "WaterSurfaceTension");
+
+			/// <summary>WaterSurfaceTension once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedWaterSurfaceTension;
 		}
 	}
 
@@ -193,10 +240,10 @@ public static class Fundamental
 		/// <summary>Gravitational constant: 6.67430 × 10⁻¹¹ m³/(kg⋅s²) (2018 CODATA)</summary>
 		public static T GravitationalConstant<T>()  where T : struct, INumber<T> => Values<T>.GravitationalConstant;
 
-		/// <summary>Magnetic permeability of free space: 4π × 10⁻⁷ H/m (exact by definition)</summary>
+		/// <summary>Magnetic permeability of free space: 1.25663706212 × 10⁻⁶ H/m (CODATA 2018; close to but no longer exactly 4π × 10⁻⁷ since the 2019 SI redefinition)</summary>
 		public static T PermeabilityOfFreeSpace<T>()  where T : struct, INumber<T> => Values<T>.PermeabilityOfFreeSpace;
 
-		/// <summary>Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (exact, derived)</summary>
+		/// <summary>Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (CODATA 2018; measured, not exact, since the 2019 SI redefinition)</summary>
 		public static T PermittivityOfFreeSpace<T>()  where T : struct, INumber<T> => Values<T>.PermittivityOfFreeSpace;
 
 		/// <summary>Planck constant: 6.62607015 × 10⁻³⁴ J·s (exact, SI defining constant)</summary>
@@ -212,31 +259,58 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Avogadro's number: 6.02214076 × 10²³ entities/mol (exact, SI defining constant)</summary>
-			internal static readonly T AvogadroNumber = T.Parse("6.02214076e23", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T AvogadroNumber => cachedAvogadroNumber ??= StorageLiteral.Constant<T>("6.02214076e23", "AvogadroNumber");
+
+			/// <summary>AvogadroNumber once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedAvogadroNumber;
 
 			/// <summary>Boltzmann constant: 1.380649 × 10⁻²³ J/K (exact, SI defining constant)</summary>
-			internal static readonly T BoltzmannConstant = T.Parse("1.380649e-23", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T BoltzmannConstant => cachedBoltzmannConstant ??= StorageLiteral.Constant<T>("1.380649e-23", "BoltzmannConstant");
+
+			/// <summary>BoltzmannConstant once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedBoltzmannConstant;
 
 			/// <summary>Elementary charge: 1.602176634 × 10⁻¹⁹ C (exact, SI defining constant)</summary>
-			internal static readonly T ElementaryCharge = T.Parse("1.602176634e-19", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T ElementaryCharge => cachedElementaryCharge ??= StorageLiteral.Constant<T>("1.602176634e-19", "ElementaryCharge");
+
+			/// <summary>ElementaryCharge once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedElementaryCharge;
 
 			/// <summary>Fine structure constant: 7.2973525693 × 10⁻³ (dimensionless, 2018 CODATA)</summary>
-			internal static readonly T FineStructureConstant = T.Parse("7.2973525693e-3", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T FineStructureConstant => cachedFineStructureConstant ??= StorageLiteral.Constant<T>("7.2973525693e-3", "FineStructureConstant");
+
+			/// <summary>FineStructureConstant once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedFineStructureConstant;
 
 			/// <summary>Gravitational constant: 6.67430 × 10⁻¹¹ m³/(kg⋅s²) (2018 CODATA)</summary>
-			internal static readonly T GravitationalConstant = T.Parse("6.67430e-11", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T GravitationalConstant => cachedGravitationalConstant ??= StorageLiteral.Constant<T>("6.67430e-11", "GravitationalConstant");
 
-			/// <summary>Magnetic permeability of free space: 4π × 10⁻⁷ H/m (exact by definition)</summary>
-			internal static readonly T PermeabilityOfFreeSpace = T.Parse("1.25663706212e-6", NumberStyles.Float, CultureInfo.InvariantCulture);
+			/// <summary>GravitationalConstant once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedGravitationalConstant;
 
-			/// <summary>Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (exact, derived)</summary>
-			internal static readonly T PermittivityOfFreeSpace = T.Parse("8.8541878128e-12", NumberStyles.Float, CultureInfo.InvariantCulture);
+			/// <summary>Magnetic permeability of free space: 1.25663706212 × 10⁻⁶ H/m (CODATA 2018; close to but no longer exactly 4π × 10⁻⁷ since the 2019 SI redefinition)</summary>
+			internal static T PermeabilityOfFreeSpace => cachedPermeabilityOfFreeSpace ??= StorageLiteral.Constant<T>("1.25663706212e-6", "PermeabilityOfFreeSpace");
+
+			/// <summary>PermeabilityOfFreeSpace once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedPermeabilityOfFreeSpace;
+
+			/// <summary>Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (CODATA 2018; measured, not exact, since the 2019 SI redefinition)</summary>
+			internal static T PermittivityOfFreeSpace => cachedPermittivityOfFreeSpace ??= StorageLiteral.Constant<T>("8.8541878128e-12", "PermittivityOfFreeSpace");
+
+			/// <summary>PermittivityOfFreeSpace once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedPermittivityOfFreeSpace;
 
 			/// <summary>Planck constant: 6.62607015 × 10⁻³⁴ J·s (exact, SI defining constant)</summary>
-			internal static readonly T PlanckConstant = T.Parse("6.62607015e-34", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T PlanckConstant => cachedPlanckConstant ??= StorageLiteral.Constant<T>("6.62607015e-34", "PlanckConstant");
+
+			/// <summary>PlanckConstant once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedPlanckConstant;
 
 			/// <summary>Speed of light in vacuum: 299,792,458 m/s (exact, SI defining constant)</summary>
-			internal static readonly T SpeedOfLight = T.Parse("299792458", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T SpeedOfLight => cachedSpeedOfLight ??= StorageLiteral.Constant<T>("299792458", "SpeedOfLight");
+
+			/// <summary>SpeedOfLight once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedSpeedOfLight;
 		}
 	}
 
@@ -258,10 +332,16 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Atomic mass unit: 1.66053906660 × 10⁻²⁷ kg (2018 CODATA)</summary>
-			internal static readonly T AtomicMassUnit = T.Parse("1.66053906660e-27", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T AtomicMassUnit => cachedAtomicMassUnit ??= StorageLiteral.Constant<T>("1.66053906660e-27", "AtomicMassUnit");
+
+			/// <summary>AtomicMassUnit once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedAtomicMassUnit;
 
 			/// <summary>Nuclear magneton: 5.0507837461 × 10⁻²⁷ J/T (2018 CODATA)</summary>
-			internal static readonly T NuclearMagneton = T.Parse("5.0507837461e-27", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T NuclearMagneton => cachedNuclearMagneton ??= StorageLiteral.Constant<T>("5.0507837461e-27", "NuclearMagneton");
+
+			/// <summary>NuclearMagneton once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedNuclearMagneton;
 		}
 	}
 
@@ -280,7 +360,10 @@ private static class Values<T>
 			where T : struct, INumber<T>
 		{
 			/// <summary>Luminous efficacy of monochromatic radiation at 540 THz: 683 lm/W (exact, SI defining constant)</summary>
-			internal static readonly T LuminousEfficacy = T.Parse("683.0", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T LuminousEfficacy => cachedLuminousEfficacy ??= StorageLiteral.Constant<T>("683.0", "LuminousEfficacy");
+
+			/// <summary>LuminousEfficacy once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedLuminousEfficacy;
 		}
 	}
 
@@ -289,7 +372,7 @@ private static class Values<T>
 	/// </summary>
 	public static class Thermodynamics
 	{
-		/// <summary>Absolute zero in Celsius: 273.15 K (exact by definition)</summary>
+		/// <summary>Absolute zero in Celsius: −273.15 °C (exact by definition)</summary>
 		public static T AbsoluteZeroInCelsius<T>()  where T : struct, INumber<T> => Values<T>.AbsoluteZeroInCelsius;
 
 		/// <summary>Standard temperature (STP): 273.15 K (0°C)</summary>
@@ -307,17 +390,29 @@ public static class Thermodynamics
 		private static class Values<T>
 			where T : struct, INumber<T>
 		{
-			/// <summary>Absolute zero in Celsius: 273.15 K (exact by definition)</summary>
-			internal static readonly T AbsoluteZeroInCelsius = T.Parse("273.15", NumberStyles.Float, CultureInfo.InvariantCulture);
+			/// <summary>Absolute zero in Celsius: −273.15 °C (exact by definition)</summary>
+			internal static T AbsoluteZeroInCelsius => cachedAbsoluteZeroInCelsius ??= StorageLiteral.Constant<T>("-273.15", "AbsoluteZeroInCelsius");
+
+			/// <summary>AbsoluteZeroInCelsius once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedAbsoluteZeroInCelsius;
 
 			/// <summary>Standard temperature (STP): 273.15 K (0°C)</summary>
-			internal static readonly T StandardTemperature = T.Parse("273.15", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T StandardTemperature => cachedStandardTemperature ??= StorageLiteral.Constant<T>("273.15", "StandardTemperature");
+
+			/// <summary>StandardTemperature once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedStandardTemperature;
 
 			/// <summary>Water boiling point at 1 atm: 373.15 K (100°C)</summary>
-			internal static readonly T WaterBoilingPoint = T.Parse("373.15", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T WaterBoilingPoint => cachedWaterBoilingPoint ??= StorageLiteral.Constant<T>("373.15", "WaterBoilingPoint");
+
+			/// <summary>WaterBoilingPoint once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedWaterBoilingPoint;
 
 			/// <summary>Water triple point: 273.16 K (exact by definition)</summary>
-			internal static readonly T WaterTriplePoint = T.Parse("273.16", NumberStyles.Float, CultureInfo.InvariantCulture);
+			internal static T WaterTriplePoint => cachedWaterTriplePoint ??= StorageLiteral.Constant<T>("273.16", "WaterTriplePoint");
+
+			/// <summary>WaterTriplePoint once materialised into <typeparamref name="T"/>.</summary>
+			private static T? cachedWaterTriplePoint;
 		}
 	}
 
@@ -326,7 +421,7 @@ private static class Values<T>
 	/// </summary>
 	public static class Generic
 	{
-		/// <summary>Gets absolute zero in celsius: 273.15 k (exact by definition) as type T.</summary>
+		/// <summary>Gets absolute zero in celsius: −273.15 °c (exact by definition) as type T.</summary>
 		public static T AbsoluteZeroInCelsius<T>()  where T : struct, INumber<T> => Thermodynamics.AbsoluteZeroInCelsius<T>();
 
 		/// <summary>Gets atomic mass unit: 1.66053906660 × 10⁻²⁷ kg (2018 codata) as type T.</summary>
@@ -359,7 +454,7 @@ public static class Generic
 		/// <summary>Gets luminous efficacy of monochromatic radiation at 540 thz: 683 lm/w (exact, si defining constant) as type T.</summary>
 		public static T LuminousEfficacy<T>()  where T : struct, INumber<T> => Optics.LuminousEfficacy<T>();
 
-		/// <summary>Gets molar volume of ideal gas at stp: 22.413969545014137 l/mol (calculated from r*t/p at 273.15k, 101325pa) as type T.</summary>
+		/// <summary>Gets molar volume of ideal gas at stp: 0.022413969545014137 m³/mol, or 22.413969545014137 l/mol (calculated from r*t/p at 273.15k, 101325pa) as type T.</summary>
 		public static T MolarVolumeSTP<T>()  where T : struct, INumber<T> => Chemistry.MolarVolumeSTP<T>();
 
 		/// <summary>Gets neutral ph value at 25°c: 7.0 as type T.</summary>
@@ -368,10 +463,10 @@ public static class Generic
 		/// <summary>Gets nuclear magneton: 5.0507837461 × 10⁻²⁷ j/t (2018 codata) as type T.</summary>
 		public static T NuclearMagneton<T>()  where T : struct, INumber<T> => NuclearPhysics.NuclearMagneton<T>();
 
-		/// <summary>Gets magnetic permeability of free space: 4π × 10⁻⁷ h/m (exact by definition) as type T.</summary>
+		/// <summary>Gets magnetic permeability of free space: 1.25663706212 × 10⁻⁶ h/m (codata 2018; close to but no longer exactly 4π × 10⁻⁷ since the 2019 si redefinition) as type T.</summary>
 		public static T PermeabilityOfFreeSpace<T>()  where T : struct, INumber<T> => Fundamental.PermeabilityOfFreeSpace<T>();
 
-		/// <summary>Gets electric permittivity of free space: 8.8541878128 × 10⁻¹² f/m (exact, derived) as type T.</summary>
+		/// <summary>Gets electric permittivity of free space: 8.8541878128 × 10⁻¹² f/m (codata 2018; measured, not exact, since the 2019 si redefinition) as type T.</summary>
 		public static T PermittivityOfFreeSpace<T>()  where T : struct, INumber<T> => Fundamental.PermittivityOfFreeSpace<T>();
 
 		/// <summary>Gets planck constant: 6.62607015 × 10⁻³⁴ j·s (exact, si defining constant) as type T.</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs
index 1b64150c..117fdb8e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration1D.g.cs
@@ -135,6 +135,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Acceleration1D by Duration to produce Jerk1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Jerk1D<T> operator /(Acceleration1D<T> left, Duration<T> right) => Jerk1D<T>.Create(left.Quantity / right.Quantity);
+	public static Jerk1D<T> operator /(Acceleration1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Jerk1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration2D.g.cs
index e9956296..8d62f214 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration2D.g.cs
@@ -60,11 +60,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -77,8 +74,7 @@ public T Distance(Acceleration2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -90,9 +86,15 @@ public T DistanceSquared(Acceleration2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Acceleration2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -109,7 +111,8 @@ public Acceleration2D<T> Normalize()
 	public static Acceleration2D<T> operator *(T scalar, Acceleration2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Acceleration2D<T> operator /(Acceleration2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Acceleration2D<T> operator /(Acceleration2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Acceleration2D<T> operator -(Acceleration2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
@@ -117,6 +120,6 @@ public Acceleration2D<T> Normalize()
 	public static Velocity2D<T> operator *(Acceleration2D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value };
 
 	/// <summary>Acceleration2D / Duration = Jerk2D.</summary>
-	public static Jerk2D<T> operator /(Acceleration2D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value };
+	public static Jerk2D<T> operator /(Acceleration2D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration3D.g.cs
index 2d564c71..293c019c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration3D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -92,8 +89,7 @@ public T Distance(Acceleration3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -106,9 +102,15 @@ public T DistanceSquared(Acceleration3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Acceleration3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -125,7 +127,8 @@ public Acceleration3D<T> Normalize()
 	public static Acceleration3D<T> operator *(T scalar, Acceleration3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Acceleration3D<T> operator /(Acceleration3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Acceleration3D<T> operator /(Acceleration3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Acceleration3D<T> operator -(Acceleration3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
@@ -133,6 +136,6 @@ public Acceleration3D<T> Normalize()
 	public static Velocity3D<T> operator *(Acceleration3D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value };
 
 	/// <summary>Acceleration3D / Duration = Jerk3D.</summary>
-	public static Jerk3D<T> operator /(Acceleration3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static Jerk3D<T> operator /(Acceleration3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration4D.g.cs
index bb5c16e9..e9d990bc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Acceleration4D.g.cs
@@ -76,11 +76,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -95,8 +92,7 @@ public T Distance(Acceleration4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -110,9 +106,15 @@ public T DistanceSquared(Acceleration4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Acceleration4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -129,7 +131,8 @@ public Acceleration4D<T> Normalize()
 	public static Acceleration4D<T> operator *(T scalar, Acceleration4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Acceleration4D<T> operator /(Acceleration4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Acceleration4D<T> operator /(Acceleration4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Acceleration4D<T> operator -(Acceleration4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
@@ -137,6 +140,6 @@ public Acceleration4D<T> Normalize()
 	public static Velocity4D<T> operator *(Acceleration4D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value, W = left.W * right.Value };
 
 	/// <summary>Acceleration4D / Duration = Jerk4D.</summary>
-	public static Jerk4D<T> operator /(Acceleration4D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
+	public static Jerk4D<T> operator /(Acceleration4D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs
index 5705be0b..69d7f11c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AccelerationMagnitude.g.cs
@@ -136,13 +136,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AccelerationMagnitude by Duration to produce JerkMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static JerkMagnitude<T> operator /(AccelerationMagnitude<T> left, Duration<T> right) => JerkMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static JerkMagnitude<T> operator /(AccelerationMagnitude<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : JerkMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides AccelerationMagnitude by JerkMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(AccelerationMagnitude<T> left, JerkMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(AccelerationMagnitude<T> left, JerkMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies AccelerationMagnitude by Area to produce GravitationalParameter.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs
index e903fd61..9762e61c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AmountOfSubstance.g.cs
@@ -132,13 +132,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AmountOfSubstance by Volume to produce Concentration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Concentration<T> operator /(AmountOfSubstance<T> left, Volume<T> right) => Concentration<T>.Create(left.Quantity / right.Quantity);
+	public static Concentration<T> operator /(AmountOfSubstance<T> left, Volume<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Concentration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides AmountOfSubstance by Concentration to produce Volume.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator /(AmountOfSubstance<T> left, Concentration<T> right) => Volume<T>.Create(left.Quantity / right.Quantity);
+	public static Volume<T> operator /(AmountOfSubstance<T> left, Concentration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Volume<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies AmountOfSubstance by MolarMass to produce Mass.
@@ -150,13 +150,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AmountOfSubstance by Duration to produce CatalyticActivity.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CatalyticActivity<T> operator /(AmountOfSubstance<T> left, Duration<T> right) => CatalyticActivity<T>.Create(left.Quantity / right.Quantity);
+	public static CatalyticActivity<T> operator /(AmountOfSubstance<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : CatalyticActivity<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides AmountOfSubstance by CatalyticActivity to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(AmountOfSubstance<T> left, CatalyticActivity<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(AmountOfSubstance<T> left, CatalyticActivity<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies AmountOfSubstance by MolarEnergy to produce Energy.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs
index a8722d60..6a509ce9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Angle.g.cs
@@ -148,12 +148,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Angle by Duration to produce AngularSpeed.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularSpeed<T> operator /(Angle<T> left, Duration<T> right) => AngularSpeed<T>.Create(left.Quantity / right.Quantity);
+	public static AngularSpeed<T> operator /(Angle<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AngularSpeed<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Angle by AngularSpeed to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Angle<T> left, AngularSpeed<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Angle<T> left, AngularSpeed<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs
index 737aa1cb..f9ce76ff 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration1D.g.cs
@@ -128,6 +128,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AngularAcceleration1D by Duration to produce AngularJerk1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularJerk1D<T> operator /(AngularAcceleration1D<T> left, Duration<T> right) => AngularJerk1D<T>.Create(left.Quantity / right.Quantity);
+	public static AngularJerk1D<T> operator /(AngularAcceleration1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AngularJerk1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration3D.g.cs
index 852fd437..395f9b28 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAcceleration3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAngularAccelerationUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(AngularAcceleration3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(AngularAcceleration3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public AngularAcceleration3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,7 +120,8 @@ public AngularAcceleration3D<T> Normalize()
 	public static AngularAcceleration3D<T> operator *(T scalar, AngularAcceleration3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static AngularAcceleration3D<T> operator /(AngularAcceleration3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static AngularAcceleration3D<T> operator /(AngularAcceleration3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static AngularAcceleration3D<T> operator -(AngularAcceleration3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
@@ -126,6 +129,6 @@ public AngularAcceleration3D<T> Normalize()
 	public static AngularVelocity3D<T> operator *(AngularAcceleration3D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value };
 
 	/// <summary>AngularAcceleration3D / Duration = AngularJerk3D.</summary>
-	public static AngularJerk3D<T> operator /(AngularAcceleration3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static AngularJerk3D<T> operator /(AngularAcceleration3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs
index 7787eedf..3b812e3f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularAccelerationMagnitude.g.cs
@@ -122,12 +122,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AngularAccelerationMagnitude by Duration to produce AngularJerkMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularJerkMagnitude<T> operator /(AngularAccelerationMagnitude<T> left, Duration<T> right) => AngularJerkMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static AngularJerkMagnitude<T> operator /(AngularAccelerationMagnitude<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AngularJerkMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides AngularAccelerationMagnitude by AngularJerkMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(AngularAccelerationMagnitude<T> left, AngularJerkMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(AngularAccelerationMagnitude<T> left, AngularJerkMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularDisplacement3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularDisplacement3D.g.cs
index 15e834f1..b94a19ce 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularDisplacement3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularDisplacement3D.g.cs
@@ -89,11 +89,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAngularDisplacementUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -113,8 +110,7 @@ public T Distance(AngularDisplacement3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -127,9 +123,15 @@ public T DistanceSquared(AngularDisplacement3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public AngularDisplacement3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -146,11 +148,12 @@ public AngularDisplacement3D<T> Normalize()
 	public static AngularDisplacement3D<T> operator *(T scalar, AngularDisplacement3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static AngularDisplacement3D<T> operator /(AngularDisplacement3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static AngularDisplacement3D<T> operator /(AngularDisplacement3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static AngularDisplacement3D<T> operator -(AngularDisplacement3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
 	/// <summary>AngularDisplacement3D / Duration = AngularVelocity3D.</summary>
-	public static AngularVelocity3D<T> operator /(AngularDisplacement3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static AngularVelocity3D<T> operator /(AngularDisplacement3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk3D.g.cs
index 71aba589..d710d19f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerk3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAngularJerkUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(AngularJerk3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(AngularJerk3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public AngularJerk3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,7 +120,8 @@ public AngularJerk3D<T> Normalize()
 	public static AngularJerk3D<T> operator *(T scalar, AngularJerk3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static AngularJerk3D<T> operator /(AngularJerk3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static AngularJerk3D<T> operator /(AngularJerk3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static AngularJerk3D<T> operator -(AngularJerk3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs
index fa8004a7..c8b7f936 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum1D.g.cs
@@ -122,6 +122,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AngularMomentum1D by Duration to produce Torque1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Torque1D<T> operator /(AngularMomentum1D<T> left, Duration<T> right) => Torque1D<T>.Create(left.Quantity / right.Quantity);
+	public static Torque1D<T> operator /(AngularMomentum1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Torque1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum3D.g.cs
index 3c22ee5f..3e937dfc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentum3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAngularMomentumUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(AngularMomentum3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(AngularMomentum3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public AngularMomentum3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,11 +120,12 @@ public AngularMomentum3D<T> Normalize()
 	public static AngularMomentum3D<T> operator *(T scalar, AngularMomentum3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static AngularMomentum3D<T> operator /(AngularMomentum3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static AngularMomentum3D<T> operator /(AngularMomentum3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static AngularMomentum3D<T> operator -(AngularMomentum3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
 	/// <summary>AngularMomentum3D / Duration = Torque3D.</summary>
-	public static Torque3D<T> operator /(AngularMomentum3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static Torque3D<T> operator /(AngularMomentum3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs
index 72f2afbe..d98f0570 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularMomentumMagnitude.g.cs
@@ -116,6 +116,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AngularMomentumMagnitude by Duration to produce TorqueMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TorqueMagnitude<T> operator /(AngularMomentumMagnitude<T> left, Duration<T> right) => TorqueMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static TorqueMagnitude<T> operator /(AngularMomentumMagnitude<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : TorqueMagnitude<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs
index 8e346728..24a0815f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularSpeed.g.cs
@@ -130,12 +130,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AngularSpeed by Duration to produce AngularAccelerationMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularAccelerationMagnitude<T> operator /(AngularSpeed<T> left, Duration<T> right) => AngularAccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static AngularAccelerationMagnitude<T> operator /(AngularSpeed<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AngularAccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides AngularSpeed by AngularAccelerationMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(AngularSpeed<T> left, AngularAccelerationMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(AngularSpeed<T> left, AngularAccelerationMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs
index 314aba9a..f85e3d18 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity1D.g.cs
@@ -135,6 +135,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides AngularVelocity1D by Duration to produce AngularAcceleration1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularAcceleration1D<T> operator /(AngularVelocity1D<T> left, Duration<T> right) => AngularAcceleration1D<T>.Create(left.Quantity / right.Quantity);
+	public static AngularAcceleration1D<T> operator /(AngularVelocity1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AngularAcceleration1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity3D.g.cs
index 4bfb30ba..23720815 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularVelocity3D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAngularVelocityUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -92,8 +89,7 @@ public T Distance(AngularVelocity3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -106,9 +102,15 @@ public T DistanceSquared(AngularVelocity3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public AngularVelocity3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -125,7 +127,8 @@ public AngularVelocity3D<T> Normalize()
 	public static AngularVelocity3D<T> operator *(T scalar, AngularVelocity3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static AngularVelocity3D<T> operator /(AngularVelocity3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static AngularVelocity3D<T> operator /(AngularVelocity3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static AngularVelocity3D<T> operator -(AngularVelocity3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
@@ -133,6 +136,6 @@ public AngularVelocity3D<T> Normalize()
 	public static AngularDisplacement3D<T> operator *(AngularVelocity3D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value };
 
 	/// <summary>AngularVelocity3D / Duration = AngularAcceleration3D.</summary>
-	public static AngularAcceleration3D<T> operator /(AngularVelocity3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static AngularAcceleration3D<T> operator /(AngularVelocity3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs
index d3d081eb..be92a44b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Area.g.cs
@@ -172,7 +172,7 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Area by Length to produce Length.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(Area<T> left, Length<T> right) => Length<T>.Create(left.Quantity / right.Quantity);
+	public static Length<T> operator /(Area<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Length<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Area by Length to produce Volume.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs
index 255a67da..c1f3bfdb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Charge.g.cs
@@ -129,6 +129,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Charge by Duration to produce Current1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Current1D<T> operator /(Charge<T> left, Duration<T> right) => Current1D<T>.Create(left.Quantity / right.Quantity);
+	public static Current1D<T> operator /(Charge<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Current1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs
index 1154b02a..a0f9d731 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ChargeMagnitude.g.cs
@@ -124,24 +124,24 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides ChargeMagnitude by Duration to produce CurrentMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator /(ChargeMagnitude<T> left, Duration<T> right) => CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static CurrentMagnitude<T> operator /(ChargeMagnitude<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ChargeMagnitude by CurrentMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(ChargeMagnitude<T> left, CurrentMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(ChargeMagnitude<T> left, CurrentMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ChargeMagnitude by VoltageMagnitude to produce Capacitance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacitance<T> operator /(ChargeMagnitude<T> left, VoltageMagnitude<T> right) => Capacitance<T>.Create(left.Quantity / right.Quantity);
+	public static Capacitance<T> operator /(ChargeMagnitude<T> left, VoltageMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Capacitance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ChargeMagnitude by Capacitance to produce VoltageMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator /(ChargeMagnitude<T> left, Capacitance<T> right) => VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static VoltageMagnitude<T> operator /(ChargeMagnitude<T> left, Capacitance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs
index b0436a0f..d99e666d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Concentration.g.cs
@@ -146,12 +146,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Concentration by Duration to produce ReactionRate.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReactionRate<T> operator /(Concentration<T> left, Duration<T> right) => ReactionRate<T>.Create(left.Quantity / right.Quantity);
+	public static ReactionRate<T> operator /(Concentration<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ReactionRate<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Concentration by ReactionRate to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Concentration<T> left, ReactionRate<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Concentration<T> left, ReactionRate<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current3D.g.cs
index 97bde74d..1724e3d2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Current3D.g.cs
@@ -75,11 +75,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IElectricCurrentUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -99,8 +96,7 @@ public T Distance(Current3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -113,9 +109,15 @@ public T DistanceSquared(Current3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Current3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -132,7 +134,8 @@ public Current3D<T> Normalize()
 	public static Current3D<T> operator *(T scalar, Current3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Current3D<T> operator /(Current3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Current3D<T> operator /(Current3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Current3D<T> operator -(Current3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs
index b368a557..34d28808 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CurrentMagnitude.g.cs
@@ -150,13 +150,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides CurrentMagnitude by VoltageMagnitude to produce Conductance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Conductance<T> operator /(CurrentMagnitude<T> left, VoltageMagnitude<T> right) => Conductance<T>.Create(left.Quantity / right.Quantity);
+	public static Conductance<T> operator /(CurrentMagnitude<T> left, VoltageMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Conductance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides CurrentMagnitude by Conductance to produce VoltageMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator /(CurrentMagnitude<T> left, Conductance<T> right) => VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static VoltageMagnitude<T> operator /(CurrentMagnitude<T> left, Conductance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies CurrentMagnitude by Inductance to produce MagneticFlux.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs
index 2d4dbafb..f830b055 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement1D.g.cs
@@ -199,6 +199,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Displacement1D by Duration to produce Velocity1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Velocity1D<T> operator /(Displacement1D<T> left, Duration<T> right) => Velocity1D<T>.Create(left.Quantity / right.Quantity);
+	public static Velocity1D<T> operator /(Displacement1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Velocity1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement2D.g.cs
index 7022ee1e..a23a31a9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement2D.g.cs
@@ -120,11 +120,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -137,8 +134,7 @@ public T Distance(Displacement2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -150,9 +146,15 @@ public T DistanceSquared(Displacement2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Displacement2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -169,11 +171,12 @@ public Displacement2D<T> Normalize()
 	public static Displacement2D<T> operator *(T scalar, Displacement2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Displacement2D<T> operator /(Displacement2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Displacement2D<T> operator /(Displacement2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Displacement2D<T> operator -(Displacement2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
 	/// <summary>Displacement2D / Duration = Velocity2D.</summary>
-	public static Velocity2D<T> operator /(Displacement2D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value };
+	public static Velocity2D<T> operator /(Displacement2D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement3D.g.cs
index 8d2a3671..7eb23c81 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement3D.g.cs
@@ -138,11 +138,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -162,8 +159,7 @@ public T Distance(Displacement3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -176,9 +172,15 @@ public T DistanceSquared(Displacement3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Displacement3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -195,12 +197,13 @@ public Displacement3D<T> Normalize()
 	public static Displacement3D<T> operator *(T scalar, Displacement3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Displacement3D<T> operator /(Displacement3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Displacement3D<T> operator /(Displacement3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Displacement3D<T> operator -(Displacement3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
 	/// <summary>Displacement3D / Duration = Velocity3D.</summary>
-	public static Velocity3D<T> operator /(Displacement3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static Velocity3D<T> operator /(Displacement3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 	/// <summary>Typed cross product: Displacement3D x Force3D = Torque3D.</summary>
 	public Torque3D<T> Cross(Force3D<T> other)
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement4D.g.cs
index 8677193c..dd4a49ac 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Displacement4D.g.cs
@@ -156,11 +156,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -175,8 +172,7 @@ public T Distance(Displacement4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -190,9 +186,15 @@ public T DistanceSquared(Displacement4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Displacement4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -209,11 +211,12 @@ public Displacement4D<T> Normalize()
 	public static Displacement4D<T> operator *(T scalar, Displacement4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Displacement4D<T> operator /(Displacement4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Displacement4D<T> operator /(Displacement4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Displacement4D<T> operator -(Displacement4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
 	/// <summary>Displacement4D / Duration = Velocity4D.</summary>
-	public static Velocity4D<T> operator /(Displacement4D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
+	public static Velocity4D<T> operator /(Displacement4D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs
index 5767532e..ce8ad6d8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DynamicViscosity.g.cs
@@ -132,6 +132,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides DynamicViscosity by Density to produce KinematicViscosity.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KinematicViscosity<T> operator /(DynamicViscosity<T> left, Density<T> right) => KinematicViscosity<T>.Create(left.Quantity / right.Quantity);
+	public static KinematicViscosity<T> operator /(DynamicViscosity<T> left, Density<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : KinematicViscosity<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField2D.g.cs
index 6e0f032f..0984f704 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField2D.g.cs
@@ -54,11 +54,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.IElectricFieldUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -71,8 +68,7 @@ public T Distance(ElectricField2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -84,9 +80,15 @@ public T DistanceSquared(ElectricField2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public ElectricField2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -103,7 +105,8 @@ public ElectricField2D<T> Normalize()
 	public static ElectricField2D<T> operator *(T scalar, ElectricField2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static ElectricField2D<T> operator /(ElectricField2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static ElectricField2D<T> operator /(ElectricField2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static ElectricField2D<T> operator -(ElectricField2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField3D.g.cs
index 4786625b..35d0968d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricField3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IElectricFieldUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(ElectricField3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(ElectricField3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public ElectricField3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,7 +120,8 @@ public ElectricField3D<T> Normalize()
 	public static ElectricField3D<T> operator *(T scalar, ElectricField3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static ElectricField3D<T> operator /(ElectricField3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static ElectricField3D<T> operator /(ElectricField3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static ElectricField3D<T> operator -(ElectricField3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs
index 2a0a7698..db023e88 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFlux.g.cs
@@ -116,12 +116,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides ElectricFlux by Area to produce ElectricFieldMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFieldMagnitude<T> operator /(ElectricFlux<T> left, Area<T> right) => ElectricFieldMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static ElectricFieldMagnitude<T> operator /(ElectricFlux<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ElectricFieldMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ElectricFlux by ElectricFieldMagnitude to produce Area.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(ElectricFlux<T> left, ElectricFieldMagnitude<T> right) => Area<T>.Create(left.Quantity / right.Quantity);
+	public static Area<T> operator /(ElectricFlux<T> left, ElectricFieldMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Area<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs
index 582e8e58..19367498 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Energy.g.cs
@@ -180,60 +180,60 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Energy by Length to produce ForceMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator /(Energy<T> left, Length<T> right) => ForceMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static ForceMagnitude<T> operator /(Energy<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ForceMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by ForceMagnitude to produce Length.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(Energy<T> left, ForceMagnitude<T> right) => Length<T>.Create(left.Quantity / right.Quantity);
+	public static Length<T> operator /(Energy<T> left, ForceMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Length<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by Volume to produce Pressure.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator /(Energy<T> left, Volume<T> right) => Pressure<T>.Create(left.Quantity / right.Quantity);
+	public static Pressure<T> operator /(Energy<T> left, Volume<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Pressure<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by Pressure to produce Volume.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator /(Energy<T> left, Pressure<T> right) => Volume<T>.Create(left.Quantity / right.Quantity);
+	public static Volume<T> operator /(Energy<T> left, Pressure<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Volume<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by Duration to produce Power.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Power<T> operator /(Energy<T> left, Duration<T> right) => Power<T>.Create(left.Quantity / right.Quantity);
+	public static Power<T> operator /(Energy<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Power<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by Power to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Energy<T> left, Power<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Energy<T> left, Power<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by Temperature to produce Entropy.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Entropy<T> operator /(Energy<T> left, Temperature<T> right) => Entropy<T>.Create(left.Quantity / right.Quantity);
+	public static Entropy<T> operator /(Energy<T> left, Temperature<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Entropy<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by Entropy to produce Temperature.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Temperature<T> operator /(Energy<T> left, Entropy<T> right) => Temperature<T>.Create(left.Quantity / right.Quantity);
+	public static Temperature<T> operator /(Energy<T> left, Entropy<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Temperature<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by AmountOfSubstance to produce MolarEnergy.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnergy<T> operator /(Energy<T> left, AmountOfSubstance<T> right) => MolarEnergy<T>.Create(left.Quantity / right.Quantity);
+	public static MolarEnergy<T> operator /(Energy<T> left, AmountOfSubstance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : MolarEnergy<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Energy by MolarEnergy to produce AmountOfSubstance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AmountOfSubstance<T> operator /(Energy<T> left, MolarEnergy<T> right) => AmountOfSubstance<T>.Create(left.Quantity / right.Quantity);
+	public static AmountOfSubstance<T> operator /(Energy<T> left, MolarEnergy<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AmountOfSubstance<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs
index 8ad959d1..18a5f5e5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Entropy.g.cs
@@ -122,12 +122,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Entropy by Mass to produce SpecificHeat.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificHeat<T> operator /(Entropy<T> left, Mass<T> right) => SpecificHeat<T>.Create(left.Quantity / right.Quantity);
+	public static SpecificHeat<T> operator /(Entropy<T> left, Mass<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : SpecificHeat<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Entropy by SpecificHeat to produce Mass.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator /(Entropy<T> left, SpecificHeat<T> right) => Mass<T>.Create(left.Quantity / right.Quantity);
+	public static Mass<T> operator /(Entropy<T> left, SpecificHeat<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Mass<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force2D.g.cs
index b7c3880c..2b4e3873 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force2D.g.cs
@@ -72,11 +72,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.IForceUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -89,8 +86,7 @@ public T Distance(Force2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -102,9 +98,15 @@ public T DistanceSquared(Force2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Force2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -121,7 +123,8 @@ public Force2D<T> Normalize()
 	public static Force2D<T> operator *(T scalar, Force2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Force2D<T> operator /(Force2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Force2D<T> operator /(Force2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Force2D<T> operator -(Force2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force3D.g.cs
index 06f2fe55..aa679fb2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force3D.g.cs
@@ -82,11 +82,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IForceUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -106,8 +103,7 @@ public T Distance(Force3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -120,9 +116,15 @@ public T DistanceSquared(Force3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Force3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -139,7 +141,8 @@ public Force3D<T> Normalize()
 	public static Force3D<T> operator *(T scalar, Force3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Force3D<T> operator /(Force3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Force3D<T> operator /(Force3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Force3D<T> operator -(Force3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force4D.g.cs
index 451e3730..b720e614 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Force4D.g.cs
@@ -92,11 +92,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.IForceUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -111,8 +108,7 @@ public T Distance(Force4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -126,9 +122,15 @@ public T DistanceSquared(Force4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Force4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -145,7 +147,8 @@ public Force4D<T> Normalize()
 	public static Force4D<T> operator *(T scalar, Force4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Force4D<T> operator /(Force4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Force4D<T> operator /(Force4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Force4D<T> operator -(Force4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs
index 9f7f8c4f..2435794d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ForceMagnitude.g.cs
@@ -140,13 +140,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides ForceMagnitude by AccelerationMagnitude to produce Mass.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator /(ForceMagnitude<T> left, AccelerationMagnitude<T> right) => Mass<T>.Create(left.Quantity / right.Quantity);
+	public static Mass<T> operator /(ForceMagnitude<T> left, AccelerationMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Mass<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ForceMagnitude by Mass to produce AccelerationMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator /(ForceMagnitude<T> left, Mass<T> right) => AccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static AccelerationMagnitude<T> operator /(ForceMagnitude<T> left, Mass<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies ForceMagnitude by Length to produce Energy.
@@ -170,18 +170,18 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides ForceMagnitude by Area to produce Pressure.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator /(ForceMagnitude<T> left, Area<T> right) => Pressure<T>.Create(left.Quantity / right.Quantity);
+	public static Pressure<T> operator /(ForceMagnitude<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Pressure<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ForceMagnitude by Length to produce SurfaceTension.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceTension<T> operator /(ForceMagnitude<T> left, Length<T> right) => SurfaceTension<T>.Create(left.Quantity / right.Quantity);
+	public static SurfaceTension<T> operator /(ForceMagnitude<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : SurfaceTension<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides ForceMagnitude by SurfaceTension to produce Length.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(ForceMagnitude<T> left, SurfaceTension<T> right) => Length<T>.Create(left.Quantity / right.Quantity);
+	public static Length<T> operator /(ForceMagnitude<T> left, SurfaceTension<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Length<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs
index 3822e3eb..6423eb27 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IAccelerationUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -92,8 +89,7 @@ public T Distance(GravitationalField3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -106,9 +102,15 @@ public T DistanceSquared(GravitationalField3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public GravitationalField3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -125,7 +127,8 @@ public GravitationalField3D<T> Normalize()
 	public static GravitationalField3D<T> operator *(T scalar, GravitationalField3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static GravitationalField3D<T> operator /(GravitationalField3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static GravitationalField3D<T> operator /(GravitationalField3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static GravitationalField3D<T> operator -(GravitationalField3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalParameter.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalParameter.g.cs
index cf5d68ee..783fd103 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalParameter.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalParameter.g.cs
@@ -124,12 +124,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides GravitationalParameter by Area to produce AccelerationMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator /(GravitationalParameter<T> left, Area<T> right) => AccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static AccelerationMagnitude<T> operator /(GravitationalParameter<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides GravitationalParameter by Length to produce SpecificEnergyMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEnergyMagnitude<T> operator /(GravitationalParameter<T> left, Length<T> right) => SpecificEnergyMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static SpecificEnergyMagnitude<T> operator /(GravitationalParameter<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : SpecificEnergyMagnitude<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
index 06d4271c..af1eae3e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
@@ -54,17 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static HalfLife<T> operator +(HalfLife<T> left, HalfLife<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HalfLife<T> operator *(HalfLife<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
+	public static HalfLife<T> operator *(HalfLife<T> left, T right) => Create(Vector0Guards.EnsurePositive(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HalfLife<T> operator *(T left, HalfLife<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
+	public static HalfLife<T> operator *(T left, HalfLife<T> right) => Create(Vector0Guards.EnsurePositive(left * right.Quantity, nameof(left)));
 
-	/// <summary>Divides a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Divides a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HalfLife<T> operator /(HalfLife<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
+	public static HalfLife<T> operator /(HalfLife<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsurePositive(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="HalfLife{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
@@ -173,14 +173,14 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(HalfLife<T> value) => Duration<T>.Create(value.Value);
 
-	/// <summary>Explicit conversion from Duration.</summary>
-	public static explicit operator HalfLife<T>(Duration<T> value) => Create(value.Value);
+	/// <summary>Explicit conversion from Duration. Throws <see cref="System.ArgumentException"/> when the value is zero, which a HalfLife cannot be.</summary>
+	public static explicit operator HalfLife<T>(Duration<T> value) => Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)));
 
-	/// <summary>Creates a HalfLife from a Duration value.</summary>
-	public static HalfLife<T> From(Duration<T> value) => Create(value.Value);
+	/// <summary>Creates a HalfLife from a Duration value. Throws <see cref="System.ArgumentException"/> when the value is zero, which a HalfLife cannot be.</summary>
+	public static HalfLife<T> From(Duration<T> value) => Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)));
 
-	/// <summary>Subtracts two HalfLife values, returning the absolute difference as a non-negative HalfLife.</summary>
+	/// <summary>Subtracts two HalfLife values, returning the absolute difference as a positive HalfLife. Throws <see cref="System.ArgumentException"/> when the two are equal, since a HalfLife cannot be zero; widen to <see cref="Duration{T}"/> first for a difference that may be.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HalfLife<T> operator -(HalfLife<T> left, HalfLife<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+	public static HalfLife<T> operator -(HalfLife<T> left, HalfLife<T> right) => Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs
index 79757f9a..0dbefdd5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk1D.g.cs
@@ -128,6 +128,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Jerk1D by Duration to produce Snap1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Snap1D<T> operator /(Jerk1D<T> left, Duration<T> right) => Snap1D<T>.Create(left.Quantity / right.Quantity);
+	public static Snap1D<T> operator /(Jerk1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Snap1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk2D.g.cs
index f8fba657..95a89900 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk2D.g.cs
@@ -54,11 +54,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.IJerkUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -71,8 +68,7 @@ public T Distance(Jerk2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -84,9 +80,15 @@ public T DistanceSquared(Jerk2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Jerk2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -103,7 +105,8 @@ public Jerk2D<T> Normalize()
 	public static Jerk2D<T> operator *(T scalar, Jerk2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Jerk2D<T> operator /(Jerk2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Jerk2D<T> operator /(Jerk2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Jerk2D<T> operator -(Jerk2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
@@ -111,6 +114,6 @@ public Jerk2D<T> Normalize()
 	public static Acceleration2D<T> operator *(Jerk2D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value };
 
 	/// <summary>Jerk2D / Duration = Snap2D.</summary>
-	public static Snap2D<T> operator /(Jerk2D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value };
+	public static Snap2D<T> operator /(Jerk2D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk3D.g.cs
index ea63b1cd..7bc8255a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IJerkUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(Jerk3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(Jerk3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Jerk3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,7 +120,8 @@ public Jerk3D<T> Normalize()
 	public static Jerk3D<T> operator *(T scalar, Jerk3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Jerk3D<T> operator /(Jerk3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Jerk3D<T> operator /(Jerk3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Jerk3D<T> operator -(Jerk3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
@@ -126,6 +129,6 @@ public Jerk3D<T> Normalize()
 	public static Acceleration3D<T> operator *(Jerk3D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value };
 
 	/// <summary>Jerk3D / Duration = Snap3D.</summary>
-	public static Snap3D<T> operator /(Jerk3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static Snap3D<T> operator /(Jerk3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk4D.g.cs
index 0fce3653..32a2fcd7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Jerk4D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.IJerkUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -87,8 +84,7 @@ public T Distance(Jerk4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -102,9 +98,15 @@ public T DistanceSquared(Jerk4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Jerk4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -121,7 +123,8 @@ public Jerk4D<T> Normalize()
 	public static Jerk4D<T> operator *(T scalar, Jerk4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Jerk4D<T> operator /(Jerk4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Jerk4D<T> operator /(Jerk4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Jerk4D<T> operator -(Jerk4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
@@ -129,6 +132,6 @@ public Jerk4D<T> Normalize()
 	public static Acceleration4D<T> operator *(Jerk4D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value, W = left.W * right.Value };
 
 	/// <summary>Jerk4D / Duration = Snap4D.</summary>
-	public static Snap4D<T> operator /(Jerk4D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
+	public static Snap4D<T> operator /(Jerk4D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs
index c2a936db..d8753c04 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/JerkMagnitude.g.cs
@@ -122,12 +122,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides JerkMagnitude by Duration to produce SnapMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SnapMagnitude<T> operator /(JerkMagnitude<T> left, Duration<T> right) => SnapMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static SnapMagnitude<T> operator /(JerkMagnitude<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : SnapMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides JerkMagnitude by SnapMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(JerkMagnitude<T> left, SnapMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(JerkMagnitude<T> left, SnapMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs
index a55156d9..9ec4d362 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Length.g.cs
@@ -216,13 +216,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Length by Duration to produce Speed.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator /(Length<T> left, Duration<T> right) => Speed<T>.Create(left.Quantity / right.Quantity);
+	public static Speed<T> operator /(Length<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Speed<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Length by Speed to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Length<T> left, Speed<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Length<T> left, Speed<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Length by Frequency to produce Speed.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs
index dfb0f293..914ceb3a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousFlux.g.cs
@@ -116,12 +116,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides LuminousFlux by Area to produce Illuminance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Illuminance<T> operator /(LuminousFlux<T> left, Area<T> right) => Illuminance<T>.Create(left.Quantity / right.Quantity);
+	public static Illuminance<T> operator /(LuminousFlux<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Illuminance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides LuminousFlux by Illuminance to produce Area.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(LuminousFlux<T> left, Illuminance<T> right) => Area<T>.Create(left.Quantity / right.Quantity);
+	public static Area<T> operator /(LuminousFlux<T> left, Illuminance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Area<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs
index 302ca4a5..4446317a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/LuminousIntensity.g.cs
@@ -124,12 +124,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides LuminousIntensity by Area to produce Luminance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Luminance<T> operator /(LuminousIntensity<T> left, Area<T> right) => Luminance<T>.Create(left.Quantity / right.Quantity);
+	public static Luminance<T> operator /(LuminousIntensity<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Luminance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides LuminousIntensity by Luminance to produce Area.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(LuminousIntensity<T> left, Luminance<T> right) => Area<T>.Create(left.Quantity / right.Quantity);
+	public static Area<T> operator /(LuminousIntensity<T> left, Luminance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Area<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs
index 41f2dc6f..397b2c30 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFlux.g.cs
@@ -116,30 +116,30 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides MagneticFlux by Area to produce MagneticFluxDensityMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFluxDensityMagnitude<T> operator /(MagneticFlux<T> left, Area<T> right) => MagneticFluxDensityMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static MagneticFluxDensityMagnitude<T> operator /(MagneticFlux<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : MagneticFluxDensityMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MagneticFlux by MagneticFluxDensityMagnitude to produce Area.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(MagneticFlux<T> left, MagneticFluxDensityMagnitude<T> right) => Area<T>.Create(left.Quantity / right.Quantity);
+	public static Area<T> operator /(MagneticFlux<T> left, MagneticFluxDensityMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Area<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MagneticFlux by Duration to produce VoltageMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator /(MagneticFlux<T> left, Duration<T> right) => VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static VoltageMagnitude<T> operator /(MagneticFlux<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MagneticFlux by CurrentMagnitude to produce Inductance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Inductance<T> operator /(MagneticFlux<T> left, CurrentMagnitude<T> right) => Inductance<T>.Create(left.Quantity / right.Quantity);
+	public static Inductance<T> operator /(MagneticFlux<T> left, CurrentMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Inductance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MagneticFlux by Inductance to produce CurrentMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator /(MagneticFlux<T> left, Inductance<T> right) => CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static CurrentMagnitude<T> operator /(MagneticFlux<T> left, Inductance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensity3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensity3D.g.cs
index 712ad5e9..5024d3ef 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensity3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensity3D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IMagneticFluxDensityUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -92,8 +89,7 @@ public T Distance(MagneticFluxDensity3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -106,9 +102,15 @@ public T DistanceSquared(MagneticFluxDensity3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public MagneticFluxDensity3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -125,7 +127,8 @@ public MagneticFluxDensity3D<T> Normalize()
 	public static MagneticFluxDensity3D<T> operator *(T scalar, MagneticFluxDensity3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static MagneticFluxDensity3D<T> operator /(MagneticFluxDensity3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static MagneticFluxDensity3D<T> operator /(MagneticFluxDensity3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static MagneticFluxDensity3D<T> operator -(MagneticFluxDensity3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs
index d0027771..b708f0fe 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Mass.g.cs
@@ -184,13 +184,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Mass by Volume to produce Density.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Density<T> operator /(Mass<T> left, Volume<T> right) => Density<T>.Create(left.Quantity / right.Quantity);
+	public static Density<T> operator /(Mass<T> left, Volume<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Density<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Mass by Density to produce Volume.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator /(Mass<T> left, Density<T> right) => Volume<T>.Create(left.Quantity / right.Quantity);
+	public static Volume<T> operator /(Mass<T> left, Density<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Volume<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Mass by SpecificHeat to produce Entropy.
@@ -202,24 +202,24 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Mass by Duration to produce MassFlowRate.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MassFlowRate<T> operator /(Mass<T> left, Duration<T> right) => MassFlowRate<T>.Create(left.Quantity / right.Quantity);
+	public static MassFlowRate<T> operator /(Mass<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : MassFlowRate<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Mass by MassFlowRate to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Mass<T> left, MassFlowRate<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Mass<T> left, MassFlowRate<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Mass by AmountOfSubstance to produce MolarMass.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarMass<T> operator /(Mass<T> left, AmountOfSubstance<T> right) => MolarMass<T>.Create(left.Quantity / right.Quantity);
+	public static MolarMass<T> operator /(Mass<T> left, AmountOfSubstance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : MolarMass<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Mass by MolarMass to produce AmountOfSubstance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AmountOfSubstance<T> operator /(Mass<T> left, MolarMass<T> right) => AmountOfSubstance<T>.Create(left.Quantity / right.Quantity);
+	public static AmountOfSubstance<T> operator /(Mass<T> left, MolarMass<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AmountOfSubstance<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs
index 96208902..a865b300 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum1D.g.cs
@@ -122,6 +122,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Momentum1D by Duration to produce Force1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Force1D<T> operator /(Momentum1D<T> left, Duration<T> right) => Force1D<T>.Create(left.Quantity / right.Quantity);
+	public static Force1D<T> operator /(Momentum1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Force1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum2D.g.cs
index bb089b35..ad961101 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum2D.g.cs
@@ -54,11 +54,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.IMomentumUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -71,8 +68,7 @@ public T Distance(Momentum2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -84,9 +80,15 @@ public T DistanceSquared(Momentum2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Momentum2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -103,11 +105,12 @@ public Momentum2D<T> Normalize()
 	public static Momentum2D<T> operator *(T scalar, Momentum2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Momentum2D<T> operator /(Momentum2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Momentum2D<T> operator /(Momentum2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Momentum2D<T> operator -(Momentum2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
 	/// <summary>Momentum2D / Duration = Force2D.</summary>
-	public static Force2D<T> operator /(Momentum2D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value };
+	public static Force2D<T> operator /(Momentum2D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum3D.g.cs
index 6f45cf0f..76477ba6 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IMomentumUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(Momentum3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(Momentum3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Momentum3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,11 +120,12 @@ public Momentum3D<T> Normalize()
 	public static Momentum3D<T> operator *(T scalar, Momentum3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Momentum3D<T> operator /(Momentum3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Momentum3D<T> operator /(Momentum3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Momentum3D<T> operator -(Momentum3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
 	/// <summary>Momentum3D / Duration = Force3D.</summary>
-	public static Force3D<T> operator /(Momentum3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static Force3D<T> operator /(Momentum3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum4D.g.cs
index 96b46993..56699e21 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Momentum4D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.IMomentumUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -87,8 +84,7 @@ public T Distance(Momentum4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -102,9 +98,15 @@ public T DistanceSquared(Momentum4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Momentum4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -121,11 +123,12 @@ public Momentum4D<T> Normalize()
 	public static Momentum4D<T> operator *(T scalar, Momentum4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Momentum4D<T> operator /(Momentum4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Momentum4D<T> operator /(Momentum4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Momentum4D<T> operator -(Momentum4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
 	/// <summary>Momentum4D / Duration = Force4D.</summary>
-	public static Force4D<T> operator /(Momentum4D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
+	public static Force4D<T> operator /(Momentum4D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs
index 21a8eeee..d1eb3d94 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentumMagnitude.g.cs
@@ -116,24 +116,24 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides MomentumMagnitude by Speed to produce Mass.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator /(MomentumMagnitude<T> left, Speed<T> right) => Mass<T>.Create(left.Quantity / right.Quantity);
+	public static Mass<T> operator /(MomentumMagnitude<T> left, Speed<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Mass<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MomentumMagnitude by Mass to produce Speed.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator /(MomentumMagnitude<T> left, Mass<T> right) => Speed<T>.Create(left.Quantity / right.Quantity);
+	public static Speed<T> operator /(MomentumMagnitude<T> left, Mass<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Speed<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MomentumMagnitude by Duration to produce ForceMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator /(MomentumMagnitude<T> left, Duration<T> right) => ForceMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static ForceMagnitude<T> operator /(MomentumMagnitude<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ForceMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides MomentumMagnitude by ForceMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(MomentumMagnitude<T> left, ForceMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(MomentumMagnitude<T> left, ForceMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
index 036d9228..2e3305bc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
@@ -54,17 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Period<T> operator +(Period<T> left, Period<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Scales a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Scales a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Period<T> operator *(Period<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
+	public static Period<T> operator *(Period<T> left, T right) => Create(Vector0Guards.EnsurePositive(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Scales a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Period<T> operator *(T left, Period<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
+	public static Period<T> operator *(T left, Period<T> right) => Create(Vector0Guards.EnsurePositive(left * right.Quantity, nameof(left)));
 
-	/// <summary>Divides a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Divides a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Period<T> operator /(Period<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
+	public static Period<T> operator /(Period<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsurePositive(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Period{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
@@ -173,14 +173,14 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(Period<T> value) => Duration<T>.Create(value.Value);
 
-	/// <summary>Explicit conversion from Duration.</summary>
-	public static explicit operator Period<T>(Duration<T> value) => Create(value.Value);
+	/// <summary>Explicit conversion from Duration. Throws <see cref="System.ArgumentException"/> when the value is zero, which a Period cannot be.</summary>
+	public static explicit operator Period<T>(Duration<T> value) => Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)));
 
-	/// <summary>Creates a Period from a Duration value.</summary>
-	public static Period<T> From(Duration<T> value) => Create(value.Value);
+	/// <summary>Creates a Period from a Duration value. Throws <see cref="System.ArgumentException"/> when the value is zero, which a Period cannot be.</summary>
+	public static Period<T> From(Duration<T> value) => Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)));
 
-	/// <summary>Subtracts two Period values, returning the absolute difference as a non-negative Period.</summary>
+	/// <summary>Subtracts two Period values, returning the absolute difference as a positive Period. Throws <see cref="System.ArgumentException"/> when the two are equal, since a Period cannot be zero; widen to <see cref="Duration{T}"/> first for a difference that may be.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Period<T> operator -(Period<T> left, Period<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+	public static Period<T> operator -(Period<T> left, Period<T> right) => Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs
index 25f4b689..b1c46c47 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs
@@ -138,11 +138,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -162,8 +159,7 @@ public T Distance(Position3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -176,9 +172,15 @@ public T DistanceSquared(Position3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Position3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -195,7 +197,8 @@ public Position3D<T> Normalize()
 	public static Position3D<T> operator *(T scalar, Position3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Position3D<T> operator /(Position3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Position3D<T> operator /(Position3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Position3D<T> operator -(Position3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs
index e36096d7..5dcae160 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Power.g.cs
@@ -140,25 +140,25 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Power by VoltageMagnitude to produce CurrentMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator /(Power<T> left, VoltageMagnitude<T> right) => CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static CurrentMagnitude<T> operator /(Power<T> left, VoltageMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Power by CurrentMagnitude to produce VoltageMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator /(Power<T> left, CurrentMagnitude<T> right) => VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static VoltageMagnitude<T> operator /(Power<T> left, CurrentMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : VoltageMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Power by Speed to produce ForceMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator /(Power<T> left, Speed<T> right) => ForceMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static ForceMagnitude<T> operator /(Power<T> left, Speed<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ForceMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Power by ForceMagnitude to produce Speed.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator /(Power<T> left, ForceMagnitude<T> right) => Speed<T>.Create(left.Quantity / right.Quantity);
+	public static Speed<T> operator /(Power<T> left, ForceMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Speed<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Power by Duration to produce Energy.
@@ -170,24 +170,24 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Power by Area to produce Irradiance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Irradiance<T> operator /(Power<T> left, Area<T> right) => Irradiance<T>.Create(left.Quantity / right.Quantity);
+	public static Irradiance<T> operator /(Power<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Irradiance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Power by Irradiance to produce Area.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(Power<T> left, Irradiance<T> right) => Area<T>.Create(left.Quantity / right.Quantity);
+	public static Area<T> operator /(Power<T> left, Irradiance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Area<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Power by Volume to produce ElectricPowerDensity.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricPowerDensity<T> operator /(Power<T> left, Volume<T> right) => ElectricPowerDensity<T>.Create(left.Quantity / right.Quantity);
+	public static ElectricPowerDensity<T> operator /(Power<T> left, Volume<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ElectricPowerDensity<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Power by ElectricPowerDensity to produce Volume.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator /(Power<T> left, ElectricPowerDensity<T> right) => Volume<T>.Create(left.Quantity / right.Quantity);
+	public static Volume<T> operator /(Power<T> left, ElectricPowerDensity<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Volume<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs
index ab24c2eb..daae2e90 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Ratio.g.cs
@@ -200,24 +200,24 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Ratio by Duration to produce Frequency.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Frequency<T> operator /(Ratio<T> left, Duration<T> right) => Frequency<T>.Create(left.Quantity / right.Quantity);
+	public static Frequency<T> operator /(Ratio<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Frequency<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Ratio by Frequency to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Ratio<T> left, Frequency<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Ratio<T> left, Frequency<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Ratio by Temperature to produce ThermalExpansionCoefficient.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalExpansionCoefficient<T> operator /(Ratio<T> left, Temperature<T> right) => ThermalExpansionCoefficient<T>.Create(left.Quantity / right.Quantity);
+	public static ThermalExpansionCoefficient<T> operator /(Ratio<T> left, Temperature<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ThermalExpansionCoefficient<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Ratio by ThermalExpansionCoefficient to produce Temperature.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Temperature<T> operator /(Ratio<T> left, ThermalExpansionCoefficient<T> right) => Temperature<T>.Create(left.Quantity / right.Quantity);
+	public static Temperature<T> operator /(Ratio<T> left, ThermalExpansionCoefficient<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Temperature<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs
index 36124ab7..d7f5823b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedAngle.g.cs
@@ -150,6 +150,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides SignedAngle by Duration to produce AngularVelocity1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularVelocity1D<T> operator /(SignedAngle<T> left, Duration<T> right) => AngularVelocity1D<T>.Create(left.Quantity / right.Quantity);
+	public static AngularVelocity1D<T> operator /(SignedAngle<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AngularVelocity1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs
index 75c3ee73..d12fc24a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SignedRatio.g.cs
@@ -191,6 +191,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides SignedRatio by Ratio to produce SignedRatio.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SignedRatio<T> operator /(SignedRatio<T> left, Ratio<T> right) => SignedRatio<T>.Create(left.Quantity / right.Quantity);
+	public static SignedRatio<T> operator /(SignedRatio<T> left, Ratio<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : SignedRatio<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap2D.g.cs
index 55f9a0b1..42896aa9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap2D.g.cs
@@ -54,11 +54,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.ISnapUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -71,8 +68,7 @@ public T Distance(Snap2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -84,9 +80,15 @@ public T DistanceSquared(Snap2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Snap2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -103,7 +105,8 @@ public Snap2D<T> Normalize()
 	public static Snap2D<T> operator *(T scalar, Snap2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Snap2D<T> operator /(Snap2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Snap2D<T> operator /(Snap2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Snap2D<T> operator -(Snap2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap3D.g.cs
index 63d870a6..33a34384 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.ISnapUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(Snap3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(Snap3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Snap3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,7 +120,8 @@ public Snap3D<T> Normalize()
 	public static Snap3D<T> operator *(T scalar, Snap3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Snap3D<T> operator /(Snap3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Snap3D<T> operator /(Snap3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Snap3D<T> operator -(Snap3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap4D.g.cs
index 67bd5d3b..a27dafcb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Snap4D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.ISnapUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -87,8 +84,7 @@ public T Distance(Snap4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -102,9 +98,15 @@ public T DistanceSquared(Snap4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Snap4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -121,7 +123,8 @@ public Snap4D<T> Normalize()
 	public static Snap4D<T> operator *(T scalar, Snap4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Snap4D<T> operator /(Snap4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Snap4D<T> operator /(Snap4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Snap4D<T> operator -(Snap4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentum3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentum3D.g.cs
index aab3c424..22f58fa4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentum3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentum3D.g.cs
@@ -61,11 +61,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.ISpecificAngularMomentumUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -85,8 +82,7 @@ public T Distance(SpecificAngularMomentum3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -99,9 +95,15 @@ public T DistanceSquared(SpecificAngularMomentum3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public SpecificAngularMomentum3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -118,7 +120,8 @@ public SpecificAngularMomentum3D<T> Normalize()
 	public static SpecificAngularMomentum3D<T> operator *(T scalar, SpecificAngularMomentum3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static SpecificAngularMomentum3D<T> operator /(SpecificAngularMomentum3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static SpecificAngularMomentum3D<T> operator /(SpecificAngularMomentum3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static SpecificAngularMomentum3D<T> operator -(SpecificAngularMomentum3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs
index ecac9e04..03a77017 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Speed.g.cs
@@ -168,25 +168,25 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Speed by Duration to produce AccelerationMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator /(Speed<T> left, Duration<T> right) => AccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static AccelerationMagnitude<T> operator /(Speed<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : AccelerationMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Speed by AccelerationMagnitude to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Speed<T> left, AccelerationMagnitude<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Speed<T> left, AccelerationMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Speed by Length to produce Frequency.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Frequency<T> operator /(Speed<T> left, Length<T> right) => Frequency<T>.Create(left.Quantity / right.Quantity);
+	public static Frequency<T> operator /(Speed<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Frequency<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Speed by Frequency to produce Length.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(Speed<T> left, Frequency<T> right) => Length<T>.Create(left.Quantity / right.Quantity);
+	public static Length<T> operator /(Speed<T> left, Frequency<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Length<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Speed by ForceMagnitude to produce Power.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs
index bedd85b8..eb121302 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs
@@ -82,11 +82,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IForceUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -106,8 +103,7 @@ public T Distance(ThrustVector<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -120,9 +116,15 @@ public T DistanceSquared(ThrustVector<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public ThrustVector<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -139,7 +141,8 @@ public ThrustVector<T> Normalize()
 	public static ThrustVector<T> operator *(T scalar, ThrustVector<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static ThrustVector<T> operator /(ThrustVector<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static ThrustVector<T> operator /(ThrustVector<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static ThrustVector<T> operator -(ThrustVector<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque3D.g.cs
index 20b025c5..9e340607 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Torque3D.g.cs
@@ -68,11 +68,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.ITorqueUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -92,8 +89,7 @@ public T Distance(Torque3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -106,9 +102,15 @@ public T DistanceSquared(Torque3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Torque3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -125,7 +127,8 @@ public Torque3D<T> Normalize()
 	public static Torque3D<T> operator *(T scalar, Torque3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Torque3D<T> operator /(Torque3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Torque3D<T> operator /(Torque3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Torque3D<T> operator -(Torque3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs
index e8d4a197..a6bd9f74 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs
@@ -138,11 +138,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.ILengthUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -162,8 +159,7 @@ public T Distance(Translation3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -176,9 +172,15 @@ public T DistanceSquared(Translation3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Translation3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -195,7 +197,8 @@ public Translation3D<T> Normalize()
 	public static Translation3D<T> operator *(T scalar, Translation3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Translation3D<T> operator /(Translation3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Translation3D<T> operator /(Translation3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Translation3D<T> operator -(Translation3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs
index 6125ef8b..97fb893f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity1D.g.cs
@@ -163,6 +163,6 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Velocity1D by Duration to produce Acceleration1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Acceleration1D<T> operator /(Velocity1D<T> left, Duration<T> right) => Acceleration1D<T>.Create(left.Quantity / right.Quantity);
+	public static Acceleration1D<T> operator /(Velocity1D<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Acceleration1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity2D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity2D.g.cs
index 8356e7b3..9294216c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity2D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity2D.g.cs
@@ -84,11 +84,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y) In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => (unit.FromBase(X), unit.FromBase(Y));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y);
@@ -101,8 +98,7 @@ public T Distance(Velocity2D<T> other)
 	{
 		T dX = X - other.X;
 		T dY = Y - other.Y;
-		T sum = (dX * dX) + (dY * dY);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -114,9 +110,15 @@ public T DistanceSquared(Velocity2D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Velocity2D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len };
 	}
 
@@ -133,7 +135,8 @@ public Velocity2D<T> Normalize()
 	public static Velocity2D<T> operator *(T scalar, Velocity2D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Velocity2D<T> operator /(Velocity2D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Velocity2D<T> operator /(Velocity2D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Velocity2D<T> operator -(Velocity2D<T> vector) => new() { X = -vector.X, Y = -vector.Y };
@@ -141,6 +144,6 @@ public Velocity2D<T> Normalize()
 	public static Displacement2D<T> operator *(Velocity2D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value };
 
 	/// <summary>Velocity2D / Duration = Acceleration2D.</summary>
-	public static Acceleration2D<T> operator /(Velocity2D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value };
+	public static Acceleration2D<T> operator /(Velocity2D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity3D.g.cs
index ab87d055..2e91f072 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity3D.g.cs
@@ -96,11 +96,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -120,8 +117,7 @@ public T Distance(Velocity3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -134,9 +130,15 @@ public T DistanceSquared(Velocity3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Velocity3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -153,7 +155,8 @@ public Velocity3D<T> Normalize()
 	public static Velocity3D<T> operator *(T scalar, Velocity3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Velocity3D<T> operator /(Velocity3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Velocity3D<T> operator /(Velocity3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Velocity3D<T> operator -(Velocity3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
@@ -161,6 +164,6 @@ public Velocity3D<T> Normalize()
 	public static Displacement3D<T> operator *(Velocity3D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value };
 
 	/// <summary>Velocity3D / Duration = Acceleration3D.</summary>
-	public static Acceleration3D<T> operator /(Velocity3D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
+	public static Acceleration3D<T> operator /(Velocity3D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity4D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity4D.g.cs
index a7834265..5bb6aee1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity4D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Velocity4D.g.cs
@@ -108,11 +108,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z, T W) In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z), unit.FromBase(W));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z) + (W * W);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z, W);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z) + (W * W);
@@ -127,8 +124,7 @@ public T Distance(Velocity4D<T> other)
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
 		T dW = W - other.W;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ) + (dW * dW);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ, dW);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -142,9 +138,15 @@ public T DistanceSquared(Velocity4D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public Velocity4D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len, W = W / len };
 	}
 
@@ -161,7 +163,8 @@ public Velocity4D<T> Normalize()
 	public static Velocity4D<T> operator *(T scalar, Velocity4D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z, W = scalar * vector.W };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static Velocity4D<T> operator /(Velocity4D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static Velocity4D<T> operator /(Velocity4D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar, W = vector.W / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static Velocity4D<T> operator -(Velocity4D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z, W = -vector.W };
@@ -169,6 +172,6 @@ public Velocity4D<T> Normalize()
 	public static Displacement4D<T> operator *(Velocity4D<T> left, Duration<T> right) => new() { X = left.X * right.Value, Y = left.Y * right.Value, Z = left.Z * right.Value, W = left.W * right.Value };
 
 	/// <summary>Velocity4D / Duration = Acceleration4D.</summary>
-	public static Acceleration4D<T> operator /(Velocity4D<T> left, Duration<T> right) => new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
+	public static Acceleration4D<T> operator /(Velocity4D<T> left, Duration<T> right) => T.IsZero(right.Value) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = left.X / right.Value, Y = left.Y / right.Value, Z = left.Z / right.Value, W = left.W / right.Value };
 
 };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs
index 57c598b8..8ccbda33 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Voltage.g.cs
@@ -129,12 +129,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Voltage by Resistance to produce Current1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Current1D<T> operator /(Voltage<T> left, Resistance<T> right) => Current1D<T>.Create(left.Quantity / right.Quantity);
+	public static Current1D<T> operator /(Voltage<T> left, Resistance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Current1D<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Voltage by Length to produce ElectricField1D.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricField1D<T> operator /(Voltage<T> left, Length<T> right) => ElectricField1D<T>.Create(left.Quantity / right.Quantity);
+	public static ElectricField1D<T> operator /(Voltage<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ElectricField1D<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs
index 45349ab3..d99ca74f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageMagnitude.g.cs
@@ -124,13 +124,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides VoltageMagnitude by Resistance to produce CurrentMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator /(VoltageMagnitude<T> left, Resistance<T> right) => CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static CurrentMagnitude<T> operator /(VoltageMagnitude<T> left, Resistance<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : CurrentMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides VoltageMagnitude by CurrentMagnitude to produce Resistance.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Resistance<T> operator /(VoltageMagnitude<T> left, CurrentMagnitude<T> right) => Resistance<T>.Create(left.Quantity / right.Quantity);
+	public static Resistance<T> operator /(VoltageMagnitude<T> left, CurrentMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Resistance<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies VoltageMagnitude by CurrentMagnitude to produce Power.
@@ -142,13 +142,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides VoltageMagnitude by Length to produce ElectricFieldMagnitude.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFieldMagnitude<T> operator /(VoltageMagnitude<T> left, Length<T> right) => ElectricFieldMagnitude<T>.Create(left.Quantity / right.Quantity);
+	public static ElectricFieldMagnitude<T> operator /(VoltageMagnitude<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : ElectricFieldMagnitude<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides VoltageMagnitude by ElectricFieldMagnitude to produce Length.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(VoltageMagnitude<T> left, ElectricFieldMagnitude<T> right) => Length<T>.Create(left.Quantity / right.Quantity);
+	public static Length<T> operator /(VoltageMagnitude<T> left, ElectricFieldMagnitude<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Length<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies VoltageMagnitude by Capacitance to produce ChargeMagnitude.
@@ -172,12 +172,12 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides VoltageMagnitude by Pressure to produce Sensitivity.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sensitivity<T> operator /(VoltageMagnitude<T> left, Pressure<T> right) => Sensitivity<T>.Create(left.Quantity / right.Quantity);
+	public static Sensitivity<T> operator /(VoltageMagnitude<T> left, Pressure<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Sensitivity<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides VoltageMagnitude by Sensitivity to produce Pressure.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator /(VoltageMagnitude<T> left, Sensitivity<T> right) => Pressure<T>.Create(left.Quantity / right.Quantity);
+	public static Pressure<T> operator /(VoltageMagnitude<T> left, Sensitivity<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Pressure<T>.Create(left.Quantity / right.Quantity);
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs
index 798bc33e..2be59b6b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Volume.g.cs
@@ -196,13 +196,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Volume by Length to produce Area.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(Volume<T> left, Length<T> right) => Area<T>.Create(left.Quantity / right.Quantity);
+	public static Area<T> operator /(Volume<T> left, Length<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Area<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Volume by Area to produce Length.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(Volume<T> left, Area<T> right) => Length<T>.Create(left.Quantity / right.Quantity);
+	public static Length<T> operator /(Volume<T> left, Area<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Length<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Volume by Pressure to produce Energy.
@@ -226,13 +226,13 @@ namespace ktsu.Semantics.Quantities;
 	/// Divides Volume by Duration to produce VolumetricFlowRate.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VolumetricFlowRate<T> operator /(Volume<T> left, Duration<T> right) => VolumetricFlowRate<T>.Create(left.Quantity / right.Quantity);
+	public static VolumetricFlowRate<T> operator /(Volume<T> left, Duration<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : VolumetricFlowRate<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Divides Volume by VolumetricFlowRate to produce Duration.
 	/// </summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Volume<T> left, VolumetricFlowRate<T> right) => Duration<T>.Create(left.Quantity / right.Quantity);
+	public static Duration<T> operator /(Volume<T> left, VolumetricFlowRate<T> right) => T.IsZero(right.Quantity) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Duration<T>.Create(left.Quantity / right.Quantity);
 
 	/// <summary>
 	/// Multiplies Volume by ElectricPowerDensity to produce Power.
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
index 6227d84f..d2b90995 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
@@ -54,17 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Wavelength<T> operator +(Wavelength<T> left, Wavelength<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Wavelength<T> operator *(Wavelength<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
+	public static Wavelength<T> operator *(Wavelength<T> left, T right) => Create(Vector0Guards.EnsurePositive(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Wavelength<T> operator *(T left, Wavelength<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
+	public static Wavelength<T> operator *(T left, Wavelength<T> right) => Create(Vector0Guards.EnsurePositive(left * right.Quantity, nameof(left)));
 
-	/// <summary>Divides a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
+	/// <summary>Divides a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the result is not positive.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Wavelength<T> operator /(Wavelength<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
+	public static Wavelength<T> operator /(Wavelength<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsurePositive(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Wavelength{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
@@ -197,14 +197,14 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Wavelength<T> value) => Length<T>.Create(value.Value);
 
-	/// <summary>Explicit conversion from Length.</summary>
-	public static explicit operator Wavelength<T>(Length<T> value) => Create(value.Value);
+	/// <summary>Explicit conversion from Length. Throws <see cref="System.ArgumentException"/> when the value is zero, which a Wavelength cannot be.</summary>
+	public static explicit operator Wavelength<T>(Length<T> value) => Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)));
 
-	/// <summary>Creates a Wavelength from a Length value.</summary>
-	public static Wavelength<T> From(Length<T> value) => Create(value.Value);
+	/// <summary>Creates a Wavelength from a Length value. Throws <see cref="System.ArgumentException"/> when the value is zero, which a Wavelength cannot be.</summary>
+	public static Wavelength<T> From(Length<T> value) => Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)));
 
-	/// <summary>Subtracts two Wavelength values, returning the absolute difference as a non-negative Wavelength.</summary>
+	/// <summary>Subtracts two Wavelength values, returning the absolute difference as a positive Wavelength. Throws <see cref="System.ArgumentException"/> when the two are equal, since a Wavelength cannot be zero; widen to <see cref="Length{T}"/> first for a difference that may be.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Wavelength<T> operator -(Wavelength<T> left, Wavelength<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+	public static Wavelength<T> operator -(Wavelength<T> left, Wavelength<T> right) => Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs
index 5d79f81c..400971b7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs
@@ -82,11 +82,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IForceUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -106,8 +103,7 @@ public T Distance(WeightVector<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -120,9 +116,15 @@ public T DistanceSquared(WeightVector<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public WeightVector<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -139,7 +141,8 @@ public WeightVector<T> Normalize()
 	public static WeightVector<T> operator *(T scalar, WeightVector<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static WeightVector<T> operator /(WeightVector<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static WeightVector<T> operator /(WeightVector<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static WeightVector<T> operator -(WeightVector<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs
index c78fd59e..47ad968b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs
@@ -96,11 +96,8 @@ namespace ktsu.Semantics.Quantities;
 	public (T X, T Y, T Z) In(global::ktsu.Semantics.Quantities.IVelocityUnit unit) => (unit.FromBase(X), unit.FromBase(Y), unit.FromBase(Z));
 
 	/// <summary>Calculates the length of the vector.</summary>
-	public T Length()
-	{
-		T sum = (X * X) + (Y * Y) + (Z * Z);
-		return StorageMath.Sqrt(sum);
-	}
+	/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>
+	public T Length() => StorageMath.Hypot(X, Y, Z);
 
 	/// <summary>Calculates the squared length of the vector.</summary>
 	public T LengthSquared() => (X * X) + (Y * Y) + (Z * Z);
@@ -120,8 +117,7 @@ public T Distance(WindVelocity3D<T> other)
 		T dX = X - other.X;
 		T dY = Y - other.Y;
 		T dZ = Z - other.Z;
-		T sum = (dX * dX) + (dY * dY) + (dZ * dZ);
-		return StorageMath.Sqrt(sum);
+		return StorageMath.Hypot(dX, dY, dZ);
 	}
 
 	/// <summary>Calculates the squared distance between two vectors.</summary>
@@ -134,9 +130,15 @@ public T DistanceSquared(WindVelocity3D<T> other)
 	}
 
 	/// <summary>Returns a normalized version of the vector.</summary>
+	/// <exception cref="System.DivideByZeroException">The vector has zero length, so it has no direction.</exception>
 	public WindVelocity3D<T> Normalize()
 	{
 		T len = Length();
+		if (T.IsZero(len))
+		{
+			throw new System.DivideByZeroException("Cannot normalize a zero-length vector.");
+		}
+
 		return new() { X = X / len, Y = Y / len, Z = Z / len };
 	}
 
@@ -153,7 +155,8 @@ public WindVelocity3D<T> Normalize()
 	public static WindVelocity3D<T> operator *(T scalar, WindVelocity3D<T> vector) => new() { X = scalar * vector.X, Y = scalar * vector.Y, Z = scalar * vector.Z };
 
 	/// <summary>Divides a vector by a scalar.</summary>
-	public static WindVelocity3D<T> operator /(WindVelocity3D<T> vector, T scalar) => new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
+	/// <exception cref="System.DivideByZeroException"><paramref name="scalar"/> is zero.</exception>
+	public static WindVelocity3D<T> operator /(WindVelocity3D<T> vector, T scalar) => T.IsZero(scalar) ? throw new System.DivideByZeroException("Cannot divide by zero.") : new() { X = vector.X / scalar, Y = vector.Y / scalar, Z = vector.Z / scalar };
 
 	/// <summary>Negates a vector.</summary>
 	public static WindVelocity3D<T> operator -(WindVelocity3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
diff --git a/Semantics.Quantities/LogarithmicStorage.cs b/Semantics.Quantities/LogarithmicStorage.cs
new file mode 100644
index 00000000..5bcb9763
--- /dev/null
+++ b/Semantics.Quantities/LogarithmicStorage.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Quantities;
+
+using System;
+using System.Globalization;
+using System.Numerics;
+
+/// <summary>
+/// Brings the <see cref="double"/> result of a logarithmic-scale conversion into the storage type, with one
+/// documented failure for a result the storage type cannot hold.
+/// </summary>
+/// <remarks>
+/// A linear value of zero is a level of negative infinity. <see cref="double"/> and <see cref="float"/> hold
+/// that; <see cref="decimal"/>, the integer types and most others do not, and <c>T.CreateChecked</c> reported it
+/// as a bare <see cref="OverflowException"/> that contradicted the conversion's own documentation. The same
+/// happens converting back from a level so high its linear value is past the type's range.
+/// </remarks>
+internal static class LogarithmicStorage
+{
+	/// <summary>Converts the level computed from a linear value.</summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="level">The level, which is negative infinity for a linear value of zero.</param>
+	/// <param name="paramName">The name of the parameter holding the linear value.</param>
+	/// <returns>The level in <typeparamref name="T"/>.</returns>
+	/// <exception cref="ArgumentOutOfRangeException">
+	/// <typeparamref name="T"/> cannot hold the level: the linear value is zero, or negative, or so near zero
+	/// that its level is past the type's range.
+	/// </exception>
+	internal static T FromLinear<T>(double level, string paramName)
+		where T : struct, INumber<T>
+	{
+		if (TryConvert(level, out T result))
+		{
+			return result;
+		}
+
+		throw new ArgumentOutOfRangeException(paramName, string.Format(
+			CultureInfo.InvariantCulture,
+			"The level of this value is {0}, which {1} cannot hold. A linear value of zero is negative infinity on every logarithmic scale.",
+			level,
+			typeof(T).Name));
+	}
+
+	/// <summary>Converts the linear value computed from a level.</summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="linear">The linear value.</param>
+	/// <returns>The linear value in <typeparamref name="T"/>.</returns>
+	/// <exception cref="OverflowException">The level is so high that <typeparamref name="T"/> cannot hold its linear value.</exception>
+	internal static T ToLinear<T>(double linear)
+		where T : struct, INumber<T>
+	{
+		if (TryConvert(linear, out T result))
+		{
+			return result;
+		}
+
+		throw new OverflowException(string.Format(
+			CultureInfo.InvariantCulture,
+			"The linear value of this level is {0}, which {1} cannot hold.",
+			linear,
+			typeof(T).Name));
+	}
+
+	private static bool TryConvert<T>(double value, out T result)
+		where T : struct, INumber<T>
+	{
+		if (double.IsNaN(value))
+		{
+			result = default;
+			return false;
+		}
+
+		try
+		{
+			result = T.CreateChecked(value);
+			return true;
+		}
+		catch (OverflowException)
+		{
+			result = default;
+			return false;
+		}
+	}
+}
diff --git a/Semantics.Quantities/StorageLiteral.cs b/Semantics.Quantities/StorageLiteral.cs
index 56326949..4026a84e 100644
--- a/Semantics.Quantities/StorageLiteral.cs
+++ b/Semantics.Quantities/StorageLiteral.cs
@@ -80,6 +80,69 @@ internal static class StorageLiteral
 		}
 	}
 
+	/// <summary>
+	/// Materialises a physical constant's literal into <typeparamref name="T"/>, for the generated
+	/// <c>PhysicalConstants</c> accessors, which call it once per constant and closed generic type.
+	/// </summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="literal">The literal as written in the metadata.</param>
+	/// <param name="name">The constant's name, for the exception message.</param>
+	/// <returns>The constant in <typeparamref name="T"/>.</returns>
+	/// <exception cref="OverflowException">The constant is too large for <typeparamref name="T"/>.</exception>
+	/// <exception cref="ArithmeticException">
+	/// <typeparamref name="T"/> holds the constant with less than about six significant digits: an integer type
+	/// truncating 9.80665 to 9, or <see cref="decimal"/> rounding 6.62607015e-34 to zero.
+	/// </exception>
+	/// <remarks>
+	/// Each constant is materialised on its own, so a constant <typeparamref name="T"/> cannot hold fails alone
+	/// rather than taking every other constant of its domain with it, which is what one shared static
+	/// initializer did. Integer types are allowed every constant that is a whole number in range, such as the
+	/// speed of light in a <see cref="long"/>.
+	/// </remarks>
+	internal static T Constant<T>(string literal, string name)
+		where T : struct, INumber<T>
+	{
+		double expected = double.Parse(literal, NumberStyles.Float, CultureInfo.InvariantCulture);
+		T value = TryParseLiteral(literal, out T parsed) ? parsed : T.CreateChecked(expected);
+
+		if (expected != 0.0 && !KeepsPrecision(value, expected))
+		{
+			throw new ArithmeticException(string.Format(
+				CultureInfo.InvariantCulture,
+				"{0} ({1}) cannot be represented in {2} without losing its precision; it would read as {3}.",
+				name,
+				literal,
+				typeof(T).Name,
+				value));
+		}
+
+		return value;
+	}
+
+	/// <summary>
+	/// Reports whether a materialised constant agrees with its <see cref="double"/> value to a relative 1e-6.
+	/// </summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="value">The constant in <typeparamref name="T"/>.</param>
+	/// <param name="expected">The constant as a <see cref="double"/>.</param>
+	/// <returns><see langword="true"/> unless the value lost precision a <see cref="float"/> would keep.</returns>
+	private static bool KeepsPrecision<T>(T value, double expected)
+		where T : struct, INumber<T>
+	{
+		double actual;
+		try
+		{
+			actual = double.CreateChecked(value);
+		}
+		catch (NotSupportedException)
+		{
+			// A type that cannot say what it holds as a double is trusted, as its parse was.
+			return true;
+		}
+
+		return Math.Abs(actual - expected) <= Math.Abs(expected) * 1e-6;
+	}
+
 	/// <summary>
 	/// Parses a literal with <see cref="NumberStyles.Float"/>, treating a parse that throws for that style
 	/// the same as one that returns <see langword="false"/>.
diff --git a/Semantics.Quantities/StorageMath.cs b/Semantics.Quantities/StorageMath.cs
index 7bc86b11..13c37cce 100644
--- a/Semantics.Quantities/StorageMath.cs
+++ b/Semantics.Quantities/StorageMath.cs
@@ -281,6 +281,82 @@ public static T Hypot<T>(T x, T y)
 		return larger * Sqrt(T.One + (ratio * ratio));
 	}
 
+	/// <summary>
+	/// The length of a three-component vector, scaled the way <see cref="Hypot{T}(T, T)"/> is so components
+	/// whose squares leave the range of <typeparamref name="T"/> still have their length (#327).
+	/// </summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="x">The first component.</param>
+	/// <param name="y">The second component.</param>
+	/// <param name="z">The third component.</param>
+	/// <returns>The square root of <c>x² + y² + z²</c>, or its floor for an integer type.</returns>
+	internal static T Hypot<T>(T x, T y, T z)
+		where T : struct, INumber<T>
+	{
+		if (IsRoundedThroughDouble<T>())
+		{
+			double dx = double.CreateChecked(x);
+			double dy = double.CreateChecked(y);
+			double dz = double.CreateChecked(z);
+			return T.CreateChecked(double.Hypot(double.Hypot(dx, dy), dz));
+		}
+
+		T larger = T.Max(T.Abs(x), T.Max(T.Abs(y), T.Abs(z)));
+		if (T.IsZero(larger))
+		{
+			return T.Zero;
+		}
+
+		if (HasFloorDivision<T>())
+		{
+			return Sqrt((x * x) + (y * y) + (z * z));
+		}
+
+		T rx = x / larger;
+		T ry = y / larger;
+		T rz = z / larger;
+		return larger * Sqrt((rx * rx) + (ry * ry) + (rz * rz));
+	}
+
+	/// <summary>
+	/// The length of a four-component vector, scaled as <see cref="Hypot{T}(T, T, T)"/> is.
+	/// </summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="x">The first component.</param>
+	/// <param name="y">The second component.</param>
+	/// <param name="z">The third component.</param>
+	/// <param name="w">The fourth component.</param>
+	/// <returns>The square root of <c>x² + y² + z² + w²</c>, or its floor for an integer type.</returns>
+	internal static T Hypot<T>(T x, T y, T z, T w)
+		where T : struct, INumber<T>
+	{
+		if (IsRoundedThroughDouble<T>())
+		{
+			double dx = double.CreateChecked(x);
+			double dy = double.CreateChecked(y);
+			double dz = double.CreateChecked(z);
+			double dw = double.CreateChecked(w);
+			return T.CreateChecked(double.Hypot(double.Hypot(dx, dy), double.Hypot(dz, dw)));
+		}
+
+		T larger = T.Max(T.Max(T.Abs(x), T.Abs(y)), T.Max(T.Abs(z), T.Abs(w)));
+		if (T.IsZero(larger))
+		{
+			return T.Zero;
+		}
+
+		if (HasFloorDivision<T>())
+		{
+			return Sqrt((x * x) + (y * y) + (z * z) + (w * w));
+		}
+
+		T rx = x / larger;
+		T ry = y / larger;
+		T rz = z / larger;
+		T rw = w / larger;
+		return larger * Sqrt((rx * rx) + (ry * ry) + (rz * rz) + (rw * rw));
+	}
+
 	/// <summary>
 	/// Reports whether <typeparamref name="T"/> is one of the primitives whose square root has always
 	/// been taken through <see cref="double"/>.
@@ -593,8 +669,19 @@ private static T RootByDescent<T>(T value, int degree, T two)
 	/// <returns>The root, to the precision the type holds.</returns>
 	/// <exception cref="ArithmeticException">The estimate does not settle within <see cref="MaximumIterations"/> steps.</exception>
 	/// <remarks>
+	/// <para>
 	/// On the same terms as <see cref="Sqrt{T}(T)"/>: an estimate that stops changing is the root, and
 	/// one alternating between two neighbours is rounding, so the smaller of the two is taken.
+	/// </para>
+	/// <para>
+	/// A type with no fixed precision, such as <c>PreciseNumber</c>, never does either: its products keep
+	/// every digit, so each estimate is about twice as long as the last and never repeats, and a step
+	/// cost four times the one before until the thread hung (#457). Such a type stops once a step moves
+	/// the estimate by less than one part in 10^60, which Newton's quadratic convergence reaches from the
+	/// <see cref="double"/> seed in about three steps. A fixed-precision type cannot hold that tolerance
+	/// (it is zero in <see cref="decimal"/>), so it settles exactly as before. A step no smaller than the
+	/// one before it has stopped converging too, and the estimate is returned there.
+	/// </para>
 	/// </remarks>
 	private static T RootBySettling<T>(T value, int degree, T two)
 		where T : struct, INumber<T>
@@ -603,6 +690,8 @@ private static T RootBySettling<T>(T value, int degree, T two)
 		T countLessOne = count - T.One;
 		T estimate = SeedForRoot(value, degree, two);
 		T previous = estimate;
+		T? lastStep = null;
+		T tolerance = RelativeTolerance<T>();
 
 		for (int iteration = 0; iteration < MaximumIterations; iteration++)
 		{
@@ -626,6 +715,19 @@ private static T RootBySettling<T>(T value, int degree, T two)
 				return T.Min(estimate, next);
 			}
 
+			T step = T.Abs(next - estimate);
+			if (step <= T.Abs(next) * tolerance)
+			{
+				return next;
+			}
+
+			// A step no smaller than the last one has stopped converging: what is left is rounding.
+			if (lastStep is T last && step >= last)
+			{
+				return estimate;
+			}
+
+			lastStep = step;
 			previous = estimate;
 			estimate = next;
 		}
@@ -633,6 +735,28 @@ private static T RootBySettling<T>(T value, int degree, T two)
 		throw new ArithmeticException($"The root of degree {degree} did not settle within {MaximumIterations} Newton steps.");
 	}
 
+	/// <summary>
+	/// The relative step below which <see cref="RootBySettling{T}"/> stops for a type that never settles.
+	/// </summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <returns>10^-60 in <typeparamref name="T"/>, or zero where the type cannot hold it.</returns>
+	private static T RelativeTolerance<T>()
+		where T : struct, INumber<T>
+	{
+		try
+		{
+			return T.CreateChecked(1e-60);
+		}
+		catch (NotSupportedException)
+		{
+			return T.Zero;
+		}
+		catch (OverflowException)
+		{
+			return T.Zero;
+		}
+	}
+
 	/// <summary>
 	/// Chooses the first Newton estimate for the <paramref name="degree"/>th root of a positive value.
 	/// </summary>
diff --git a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
index dfdef786..55931af7 100644
--- a/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/LogarithmicScalesGenerator.cs
@@ -175,8 +175,9 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 		cb.WriteLine($"/// {conversion.FromSummary ?? $"Creates a value from the linear {linear}."}");
 		cb.WriteLine(Emit.SummaryClose);
 		cb.WriteLine($"/// <param name=\"linear\">The linear <see cref=\"{linear}{{T}}\"/>.</param>");
-		cb.WriteLine($"/// <returns>A new <see cref=\"{scale.Name}{{T}}\"/>. A linear value of zero maps to negative infinity.</returns>");
+		cb.WriteLine($"/// <returns>A new <see cref=\"{scale.Name}{{T}}\"/>. A linear value of zero maps to negative infinity where <typeparamref name=\"T\"/> can hold it.</returns>");
 		WriteDoublePrecisionRemarks(cb);
+		cb.WriteLine("/// <exception cref=\"ArgumentOutOfRangeException\"><typeparamref name=\"T\"/> cannot hold the result, as for a linear value of zero with <see langword=\"decimal\"/> or integer storage.</exception>");
 		cb.WriteLine($"public static {fullType} {fromName}({linear}<T> linear)");
 		using (new Scope(cb))
 		{
@@ -186,7 +187,7 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 				cb.WriteLine($"double reference = {referenceExpr};");
 			}
 
-			cb.WriteLine($"return new(T.CreateChecked({multiplier} * {logExpr}));");
+			cb.WriteLine($"return new(LogarithmicStorage.FromLinear<T>({multiplier} * {logExpr}, nameof(linear)));");
 		}
 
 		cb.NewLine();
@@ -201,6 +202,7 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 		cb.WriteLine(Emit.SummaryClose);
 		cb.WriteLine($"/// <returns>The linear <see cref=\"{linear}{{T}}\"/>.</returns>");
 		WriteDoublePrecisionRemarks(cb);
+		cb.WriteLine("/// <exception cref=\"OverflowException\"><typeparamref name=\"T\"/> cannot hold the linear value of a level this high.</exception>");
 		cb.WriteLine($"public {linear}<T> {toName}()");
 		using (new Scope(cb))
 		{
@@ -210,7 +212,7 @@ private static void WriteConversion(CodeBlocker cb, LogarithmicScaleDefinition s
 				cb.WriteLine($"double reference = {referenceExpr};");
 			}
 
-			cb.WriteLine($"return {linear}<T>.Create(T.CreateChecked({inverseExpr}));");
+			cb.WriteLine($"return {linear}<T>.Create(LogarithmicStorage.ToLinear<T>({inverseExpr}));");
 		}
 
 		cb.NewLine();
diff --git a/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs b/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
index 6141b865..1bb33f81 100644
--- a/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/PhysicalConstantsGenerator.cs
@@ -26,8 +26,8 @@ public class PhysicalConstantsGenerator : SemanticsGenerator<DomainsMetadata>
 {
 	/// <summary>
 	/// Name of the private nested holder that caches the parsed value of each constant per closed
-	/// generic type. A static field on a generic type is initialised once per <c>T</c>, so callers
-	/// pay the parse exactly once regardless of how hot the accessor is.
+	/// generic type. A static field on a generic type exists once per <c>T</c>, so callers pay the
+	/// parse once per constant regardless of how hot the accessor is.
 	/// </summary>
 	private const string HolderName = "Values";
 
@@ -37,12 +37,10 @@ public class PhysicalConstantsGenerator : SemanticsGenerator<DomainsMetadata>
 	private const string NumericConstraint = "where T : struct, INumber<T>";
 
 	/// <summary>
-	/// Styles accepted when parsing a constant literal. <see cref="System.Globalization.NumberStyles.Float"/>
-	/// covers the exponent forms used in the metadata (for example <c>6.62607015e-34</c>); the default
-	/// <c>Parse(string, IFormatProvider)</c> overload resolves to <c>NumberStyles.Number</c> for some
-	/// numeric types, which rejects an exponent, so the style is always passed explicitly.
+	/// Prefix of the private field caching each constant once it has been materialised. Each constant is
+	/// materialised on its own, through <c>StorageLiteral.Constant</c>, when it is first read.
 	/// </summary>
-	private const string ParseStyles = "NumberStyles.Float";
+	private const string CachePrefix = "cached";
 
 	public PhysicalConstantsGenerator() : base("domains.json") { }
 
@@ -60,7 +58,6 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 			Namespace = "ktsu.Semantics.Quantities",
 			Usings =
 			{
-				"System.Globalization",
 				"System.Numerics",
 			},
 		};
@@ -125,12 +122,20 @@ protected override void Generate(SourceProductionContext context, DomainsMetadat
 					BodyFactory = (body) => body.Write($" {NumericConstraint} => {HolderName}<T>.{constant.Name};"),
 				});
 
+				// One lazily filled field per constant, so a constant T cannot hold throws from its own accessor
+				// rather than failing the shared static initializer for every constant of the domain.
 				holderClass.Members.Add(new FieldTemplate()
 				{
 					Comments = {$"/// <summary>{constant.Description}</summary>"},
-					Keywords = {Emit.Internal, Emit.Static, "readonly", "T"},
-					Name = constant.Name,
-					DefaultValue = $"T.Parse(\"{constant.Value}\", {ParseStyles}, CultureInfo.InvariantCulture)",
+					Keywords = {Emit.Internal, Emit.Static, "T"},
+					Name = $"{constant.Name} => {CachePrefix}{constant.Name} ??= StorageLiteral.Constant<T>(\"{constant.Value}\", \"{constant.Name}\")",
+				});
+
+				holderClass.Members.Add(new FieldTemplate()
+				{
+					Comments = {$"/// <summary>{constant.Name} once materialised into <typeparamref name=\"T\"/>.</summary>"},
+					Keywords = {"private", Emit.Static, "T?"},
+					Name = $"{CachePrefix}{constant.Name}",
 				});
 			}
 
diff --git a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
index 0590f630..07792cd5 100644
--- a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
@@ -783,7 +783,7 @@ private static void AddDimensionAndInMembers(
 	/// <c>T.Abs(left - right)</c>, per the locked decision in #52 — so the plain one is skipped
 	/// rather than emitted twice.
 	/// </param>
-	private static void AddValueTypeCore(ClassTemplate cls, string fullType, bool isV0)
+	private static void AddValueTypeCore(ClassTemplate cls, string fullType, bool isV0, bool strictPositive = false)
 	{
 		// A doc comment is XML, so the type argument is spelled with braces: Mass{T}, not Mass<T>.
 		string docRef = $"<see cref=\"{fullType.Replace('<', '{').Replace('>', '}')}\"/>";
@@ -888,10 +888,17 @@ private static void AddValueTypeCore(ClassTemplate cls, string fullType, bool is
 			});
 		}
 
-		string scaledLeft = isV0 ? "Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)))" : "Create(left.Quantity * right)";
-		string scaledRight = isV0 ? "Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)))" : "Create(left * right.Quantity)";
-		string divided = isV0 ? "Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)))" : "Create(left.Quantity / right)";
-		string scaleRemark = isV0 ? " Throws <see cref=\"System.ArgumentException\"/> when the number is negative." : string.Empty;
+		// A strictly positive overload (#51) keeps its stricter rule through scaling too (#354), so
+		// w * 0 and w / infinity cannot produce the zero its factories refuse.
+		string guard = strictPositive ? "EnsurePositive" : "EnsureNonNegative";
+		string scaledLeft = isV0 ? $"Create(Vector0Guards.{guard}(left.Quantity * right, nameof(right)))" : "Create(left.Quantity * right)";
+		string scaledRight = isV0 ? $"Create(Vector0Guards.{guard}(left * right.Quantity, nameof(left)))" : "Create(left * right.Quantity)";
+		string divided = isV0 ? $"Create(Vector0Guards.{guard}(left.Quantity / right, nameof(right)))" : "Create(left.Quantity / right)";
+		string scaleRemark = !isV0
+			? string.Empty
+			: strictPositive
+				? " Throws <see cref=\"System.ArgumentException\"/> when the result is not positive."
+				: " Throws <see cref=\"System.ArgumentException\"/> when the number is negative.";
 
 		AddBinaryOperator(cls, fullType, "*", fullType, "T", $"=> {scaledLeft};",
 			$"Scales a {docRef} by a bare number.{scaleRemark}");
@@ -1279,8 +1286,10 @@ private void EmitOverloadType(
 			Constraints = {"where T : struct, INumber<T>"},
 		};
 
+		bool strictPositive = type.Magnitude == Magnitude.Positive;
+
 		// Everything a quantity used to inherit from the PhysicalQuantity record.
-		AddValueTypeCore(cls, fullType, isV0: vectorForm == 0);
+		AddValueTypeCore(cls, fullType, isV0: vectorForm == 0, strictPositive: strictPositive);
 
 		// Zero property
 		cls.Members.Add(new FieldTemplate()
@@ -1296,7 +1305,6 @@ private void EmitOverloadType(
 		// dimensions.json (#51, e.g. Wavelength, Period, HalfLife) get the stricter
 		// EnsurePositive guard so a zero input is rejected too. V1 overloads accept
 		// any sign, and like their V1 base hold a difference, so they leave out the unit offset (#283).
-		bool strictPositive = type.Magnitude == Magnitude.Positive;
 		AddUnitFactories(
 			cls,
 			dim.AvailableUnits,
@@ -1319,35 +1327,48 @@ private void EmitOverloadType(
 			BodyFactory = (body) => body.Write($"=> {baseFullType}.Create(value.Value);"),
 		});
 
+		// Narrowing takes the overload's own rule with it: a strictly positive overload refuses a zero
+		// base (#354). The base already guarantees anything weaker.
+		string narrowed = strictPositive ? "Create(Vector0Guards.EnsurePositive(value.Value, nameof(value)))" : "Create(value.Value)";
+		string narrowRemark = strictPositive ? $" Throws <see cref=\"System.ArgumentException\"/> when the value is zero, which a {typeName} cannot be." : string.Empty;
+
 		// Explicit narrowing from base type
 		cls.Members.Add(new MethodTemplate()
 		{
-			Comments = {$"/// <summary>Explicit conversion from {baseTypeName}.</summary>"},
+			Comments = {$"/// <summary>Explicit conversion from {baseTypeName}.{narrowRemark}</summary>"},
 			Keywords = {Emit.Public, Emit.Static, "explicit", "operator"},
 			Name = fullType,
 			Parameters = {new ParameterTemplate { Type = baseFullType, Name = Emit.ValueParameter }},
-			BodyFactory = (body) => body.Write($"=> Create(value.Value);"),
+			BodyFactory = (body) => body.Write($"=> {narrowed};"),
 		});
 
 		// Factory-style narrowing from base
 		cls.Members.Add(new MethodTemplate()
 		{
-			Comments = {$"/// <summary>Creates a {typeName} from a {baseTypeName} value.</summary>"},
+			Comments = {$"/// <summary>Creates a {typeName} from a {baseTypeName} value.{narrowRemark}</summary>"},
 			Keywords = {Emit.Public, Emit.Static, fullType},
 			Name = "From",
 			Parameters = {new ParameterTemplate { Type = baseFullType, Name = Emit.ValueParameter }},
-			BodyFactory = (body) => body.Write("=> Create(value.Value);"),
+			BodyFactory = (body) => body.Write($"=> {narrowed};"),
 		});
 
 		// V0 overload subtraction returns the same V0 of T.Abs(left - right) (locked
 		// in #52). The overload-typed operator hides the base PhysicalQuantity's plain
 		// subtraction so overloads stay in their own type and the magnitude invariant
 		// is preserved.
+		// For a strictly positive overload the difference of two equal values is zero, which the type
+		// cannot hold, so it throws like every other path to zero (#354).
 		if (vectorForm == 0)
 		{
+			string difference = strictPositive
+				? "=> Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));"
+				: "=> Create(T.Abs(left.Quantity - right.Quantity));";
+			string differenceSummary = strictPositive
+				? $"/// <summary>Subtracts two {typeName} values, returning the absolute difference as a positive {typeName}. Throws <see cref=\"System.ArgumentException\"/> when the two are equal, since a {typeName} cannot be zero; widen to <see cref=\"{baseTypeName}{{T}}\"/> first for a difference that may be.</summary>"
+				: $"/// <summary>Subtracts two {typeName} values, returning the absolute difference as a non-negative {typeName}.</summary>";
 			cls.Members.Add(new MethodTemplate()
 			{
-				Comments = {$"/// <summary>Subtracts two {typeName} values, returning the absolute difference as a non-negative {typeName}.</summary>"},
+				Comments = {differenceSummary},
 				Attributes = {Emit.PhysicsOperatorSuppression},
 				Keywords = {Emit.Public, Emit.Static, fullType},
 				Name = "operator -",
@@ -1356,7 +1377,7 @@ private void EmitOverloadType(
 					new ParameterTemplate { Type = fullType, Name = "left" },
 					new ParameterTemplate { Type = fullType, Name = Emit.RightParameter },
 				},
-				BodyFactory = (body) => body.Write("=> Create(T.Abs(left.Quantity - right.Quantity));"),
+				BodyFactory = (body) => body.Write(difference),
 			});
 		}
 
@@ -1504,8 +1525,9 @@ private static void EmitScalarOperators(ClassTemplate cls, string ownerTypeName,
 						new ParameterTemplate { Type = $"{op.LeftTypeName}<T>", Name = "left" },
 						new ParameterTemplate { Type = $"{op.RightTypeName}<T>", Name = Emit.RightParameter },
 					},
-					BodyFactory = (body) => body.Write(
-						$"=> {op.ReturnTypeName}<T>.Create(left.Quantity {op.Op} right.Quantity);"),
+					BodyFactory = (body) => body.Write(op.Op == "/"
+						? $"=> {DivideByZeroGuard("right.Quantity")}{op.ReturnTypeName}<T>.Create(left.Quantity / right.Quantity);"
+						: $"=> {op.ReturnTypeName}<T>.Create(left.Quantity {op.Op} right.Quantity);"),
 				});
 			}
 			else
@@ -1542,7 +1564,8 @@ private static void EmitInlineCrossDimOp(ClassTemplate cls, OperatorInfo op, Emi
 		{
 			// VN op V0: component-wise with right.Value
 			string initExpr = string.Join(", ", resultComponents.Select(c => $"{c} = left.{c} {op.Op} right.Value"));
-			bodyExpr = $"=> new() {{ {initExpr} }};";
+			string guard = op.Op == "/" ? DivideByZeroGuard("right.Value") : string.Empty;
+			bodyExpr = $"=> {guard}new() {{ {initExpr} }};";
 		}
 		else if (leftForm <= 1 && rightForm >= 2)
 		{
@@ -1608,8 +1631,9 @@ private static void EmitVectorCrossDimOperators(CodeBlocker cb, string ownerType
 			{
 				// VN * V0 or VN / V0 => VN result
 				string initExpr = string.Join(", ", resultComponents.Select(c => $"{c} = left.{c} {op.Op} right.Value"));
+				string guard = op.Op == "/" ? DivideByZeroGuard("right.Value") : string.Empty;
 				cb.WriteLine($"/// <summary>{op.LeftTypeName} {op.Op} {op.RightTypeName} = {op.ReturnTypeName}.</summary>");
-				cb.WriteLine($"public static {op.ReturnTypeName}<T> operator {op.Op}({op.LeftTypeName}<T> left, {op.RightTypeName}<T> right) => new() {{ {initExpr} }};");
+				cb.WriteLine($"public static {op.ReturnTypeName}<T> operator {op.Op}({op.LeftTypeName}<T> left, {op.RightTypeName}<T> right) => {guard}new() {{ {initExpr} }};");
 				cb.NewLine();
 			}
 			else if (leftForm <= 1 && rightForm >= 2 && op.Op == "*")
@@ -1815,13 +1839,11 @@ private static void WriteVectorMethods(CodeBlocker cb, string fullType, string[]
 	{
 		string sumOfSquares = string.Join(" + ", components.Select(c => $"({c} * {c})"));
 
+		// The norm is scaled by the largest component rather than squared and summed, so a vector
+		// whose squares leave the storage type still has its length (#327).
 		cb.WriteLine("/// <summary>Calculates the length of the vector.</summary>");
-		cb.WriteLine("public T Length()");
-		using (new Scope(cb))
-		{
-			cb.WriteLine($"T sum = {sumOfSquares};");
-			cb.WriteLine("return StorageMath.Sqrt(sum);");
-		}
+		cb.WriteLine("/// <remarks>Computed without squaring the components outright, so a length the storage type can hold is returned even when the squares of the components are past its range.</remarks>");
+		cb.WriteLine($"public T Length() => StorageMath.Hypot({string.Join(", ", components)});");
 
 		cb.NewLine();
 
@@ -1855,9 +1877,7 @@ private static void WriteVectorMethods(CodeBlocker cb, string fullType, string[]
 				cb.WriteLine($"T d{comp} = {comp} - other.{comp};");
 			}
 
-			string distSum = string.Join(" + ", components.Select(c => $"(d{c} * d{c})"));
-			cb.WriteLine($"T sum = {distSum};");
-			cb.WriteLine("return StorageMath.Sqrt(sum);");
+			cb.WriteLine($"return StorageMath.Hypot({string.Join(", ", components.Select(c => $"d{c}"))});");
 		}
 
 		cb.NewLine();
@@ -1878,10 +1898,18 @@ private static void WriteVectorMethods(CodeBlocker cb, string fullType, string[]
 		cb.NewLine();
 
 		cb.WriteLine("/// <summary>Returns a normalized version of the vector.</summary>");
+		cb.WriteLine("/// <exception cref=\"System.DivideByZeroException\">The vector has zero length, so it has no direction.</exception>");
 		cb.WriteLine($"public {fullType} Normalize()");
 		using (new Scope(cb))
 		{
 			cb.WriteLine("T len = Length();");
+			cb.WriteLine("if (T.IsZero(len))");
+			using (new Scope(cb))
+			{
+				cb.WriteLine("throw new System.DivideByZeroException(\"Cannot normalize a zero-length vector.\");");
+			}
+
+			cb.NewLine();
 			string normInit = string.Join(", ", components.Select(c => $"{c} = {c} / len"));
 			cb.WriteLine($"return new() {{ {normInit} }};");
 		}
@@ -1913,7 +1941,8 @@ private static void WriteVectorOperators(CodeBlocker cb, string fullType, string
 
 		string divInit = string.Join(", ", components.Select(c => $"{c} = vector.{c} / scalar"));
 		cb.WriteLine("/// <summary>Divides a vector by a scalar.</summary>");
-		cb.WriteLine($"public static {fullType} operator /({fullType} vector, T scalar) => new() {{ {divInit} }};");
+		cb.WriteLine("/// <exception cref=\"System.DivideByZeroException\"><paramref name=\"scalar\"/> is zero.</exception>");
+		cb.WriteLine($"public static {fullType} operator /({fullType} vector, T scalar) => {DivideByZeroGuard("scalar")}new() {{ {divInit} }};");
 		cb.NewLine();
 
 		string negInit = string.Join(", ", components.Select(c => $"{c} = -vector.{c}"));
@@ -1925,6 +1954,16 @@ private static void WriteVectorOperators(CodeBlocker cb, string fullType, string
 
 	#region Helper Methods
 
+	/// <summary>
+	/// The start of an expression body that throws <see cref="DivideByZeroException"/> when
+	/// <paramref name="divisor"/> is zero, the same way the same-dimension operators do (#480), so a
+	/// quotient never holds an infinity or a NaN that the factories would have refused.
+	/// </summary>
+	/// <param name="divisor">The expression divided by.</param>
+	/// <returns>A conditional to put before the quotient.</returns>
+	private static string DivideByZeroGuard(string divisor) =>
+		$"T.IsZero({divisor}) ? throw new System.DivideByZeroException(\"Cannot divide by zero.\") : ";
+
 	private static VectorFormDefinition? GetFormDef(PhysicalDimension dim, int form) => form switch
 	{
 		0 => dim.Quantities.Vector0,
diff --git a/Semantics.SourceGenerators/Metadata/domains.json b/Semantics.SourceGenerators/Metadata/domains.json
index 84097a95..c3c4ade5 100644
--- a/Semantics.SourceGenerators/Metadata/domains.json
+++ b/Semantics.SourceGenerators/Metadata/domains.json
@@ -36,12 +36,12 @@
         },
         {
           "name": "PermittivityOfFreeSpace",
-          "description": "Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (exact, derived)",
+          "description": "Electric permittivity of free space: 8.8541878128 × 10⁻¹² F/m (CODATA 2018; measured, not exact, since the 2019 SI redefinition)",
           "value": "8.8541878128e-12"
         },
         {
           "name": "PermeabilityOfFreeSpace",
-          "description": "Magnetic permeability of free space: 4π × 10⁻⁷ H/m (exact by definition)",
+          "description": "Magnetic permeability of free space: 1.25663706212 × 10⁻⁶ H/m (CODATA 2018; close to but no longer exactly 4π × 10⁻⁷ since the 2019 SI redefinition)",
           "value": "1.25663706212e-6"
         },
         {
@@ -133,8 +133,8 @@
       "constants": [
         {
           "name": "AbsoluteZeroInCelsius",
-          "description": "Absolute zero in Celsius: 273.15 K (exact by definition)",
-          "value": "273.15"
+          "description": "Absolute zero in Celsius: −273.15 °C (exact by definition)",
+          "value": "-273.15"
         },
         {
           "name": "WaterTriplePoint",
@@ -223,12 +223,12 @@
         {
           "name": "WaterIonProduct",
           "description": "Water ion product (Kw) at 25°C: 1.0 × 10⁻¹⁴ (pKw = 14.0)",
-          "value": "14.0"
+          "value": "1.0e-14"
         },
         {
           "name": "MolarVolumeSTP",
-          "description": "Molar volume of ideal gas at STP: 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)",
-          "value": "22.413969545014137"
+          "description": "Molar volume of ideal gas at STP: 0.022413969545014137 m³/mol, or 22.413969545014137 L/mol (calculated from R*T/P at 273.15K, 101325Pa)",
+          "value": "0.022413969545014137"
         },
         {
           "name": "Ln2",
diff --git a/Semantics.Test/Quantities/PhysicsBugfixTests.cs b/Semantics.Test/Quantities/PhysicsBugfixTests.cs
new file mode 100644
index 00000000..ee7cd741
--- /dev/null
+++ b/Semantics.Test/Quantities/PhysicsBugfixTests.cs
@@ -0,0 +1,135 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Test.Quantities;
+
+using System;
+using ktsu.Semantics.Quantities;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Constants that are right and survive their siblings (#386, #392), logarithmic conversions with no
+/// infinity to land on (#352), strictly positive overloads that stay positive (#354), and division by zero
+/// that throws on every generated path (#480).
+/// </summary>
+[TestClass]
+public sealed class PhysicsBugfixTests
+{
+	[TestMethod]
+	public void AbsoluteZeroInCelsiusIsZeroKelvin()
+	{
+		double celsius = PhysicalConstants.Generic.AbsoluteZeroInCelsius<double>();
+		Assert.AreEqual(-273.15, celsius, 1e-12);
+		Assert.AreEqual(0.0, Temperature<double>.FromCelsius(celsius).Value, 1e-9);
+	}
+
+	[TestMethod]
+	public void WaterIonProductIsKw()
+	{
+		Assert.AreEqual(1e-14, PhysicalConstants.Generic.WaterIonProduct<double>(), 1e-28);
+	}
+
+	[TestMethod]
+	public void MolarVolumeStpIsInCubicMetresPerMole()
+	{
+		double expected = PhysicalConstants.Generic.GasConstant<double>() * 273.15 / 101325.0;
+		Assert.AreEqual(expected, PhysicalConstants.Generic.MolarVolumeSTP<double>(), 1e-12);
+	}
+
+	[TestMethod]
+	public void IntegerStorageReadsTheConstantsItCanHold()
+	{
+		Assert.AreEqual(299792458L, PhysicalConstants.Fundamental.SpeedOfLight<long>());
+		Assert.AreEqual(101325, PhysicalConstants.ClassicalMechanics.StandardAtmosphericPressure<int>());
+		Assert.AreEqual(7, PH<int>.Neutral.Value);
+	}
+
+	[TestMethod]
+	public void AConstantTheStorageTypeCannotHoldFailsAlone()
+	{
+		Assert.ThrowsExactly<OverflowException>(() => PhysicalConstants.Fundamental.AvogadroNumber<long>());
+		Assert.ThrowsExactly<ArithmeticException>(() => PhysicalConstants.ClassicalMechanics.StandardGravity<int>());
+		Assert.AreEqual(299792458L, PhysicalConstants.Fundamental.SpeedOfLight<long>());
+	}
+
+	[TestMethod]
+	public void DecimalRefusesAConstantItWouldRoundAway()
+	{
+		Assert.ThrowsExactly<ArithmeticException>(() => PhysicalConstants.Fundamental.PlanckConstant<decimal>());
+		Assert.ThrowsExactly<ArithmeticException>(() => PhysicalConstants.NuclearPhysics.AtomicMassUnit<decimal>());
+		Assert.AreEqual(299792458m, PhysicalConstants.Fundamental.SpeedOfLight<decimal>());
+	}
+
+	[TestMethod]
+	public void ALinearZeroWithNoInfinityToHoldThrowsArgumentOutOfRange()
+	{
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Gain<decimal>.Silence.ToDecibels());
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Gain<int>.Silence.ToDecibels());
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => SoundPressureLevel<decimal>.FromSoundPressure(SoundPressure<decimal>.Zero));
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => PH<decimal>.FromHydrogenConcentration(Concentration<decimal>.Zero));
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Semitones<decimal>.FromFrequencyRatio(Ratio<decimal>.Zero));
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Decibels<decimal>.FromAmplitude(0m));
+		Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => Decibels<decimal>.FromPower(0m));
+	}
+
+	[TestMethod]
+	public void ALinearZeroIsNegativeInfinityWhereTheTypeHoldsIt()
+	{
+		Assert.AreEqual(double.NegativeInfinity, Gain<double>.Silence.ToDecibels().Value);
+		Assert.AreEqual(float.NegativeInfinity, Gain<float>.Silence.ToDecibels().Value);
+	}
+
+	[TestMethod]
+	public void ALevelTooHighForTheLinearTypeThrowsOverflow() =>
+		Assert.ThrowsExactly<OverflowException>(() => Decibels<decimal>.Create(600m).ToAmplitude());
+
+	[TestMethod]
+	public void StrictlyPositiveOverloadsDoNotReachZero()
+	{
+		Wavelength<double> w = Wavelength<double>.FromMeter(1);
+		Period<double> p = Period<double>.FromSecond(1);
+		HalfLife<double> h = HalfLife<double>.FromSecond(1);
+
+		Assert.ThrowsExactly<ArgumentException>(() => w * 0.0);
+		Assert.ThrowsExactly<ArgumentException>(() => 0.0 * w);
+		Assert.ThrowsExactly<ArgumentException>(() => w - w);
+		Assert.ThrowsExactly<ArgumentException>(() => w / double.PositiveInfinity);
+		Assert.ThrowsExactly<ArgumentException>(() => Wavelength<double>.From(Length<double>.Zero));
+		Assert.ThrowsExactly<ArgumentException>(() => (Wavelength<double>)Length<double>.Zero);
+		Assert.ThrowsExactly<ArgumentException>(() => p - p);
+		Assert.ThrowsExactly<ArgumentException>(() => p * 0.0);
+		Assert.ThrowsExactly<ArgumentException>(() => h - h);
+		Assert.ThrowsExactly<ArgumentException>(() => HalfLife<double>.From(Duration<double>.Zero));
+
+		Assert.AreEqual(2.0, (w * 2.0).Value);
+		Assert.AreEqual(1.0, (Wavelength<double>.FromMeter(3) - Wavelength<double>.FromMeter(2)).Value);
+	}
+
+	[TestMethod]
+	public void UnconstrainedOverloadsStillAcceptZero()
+	{
+		Assert.AreEqual(0.0, (Distance<double>.FromMeter(1) * 0.0).Value);
+		Assert.AreEqual(0.0, Distance<double>.From(Length<double>.Zero).Value);
+		Assert.AreEqual(0.0, (Length<double>.FromMeter(1) * 0.0).Value);
+	}
+
+	[TestMethod]
+	public void DivisionByZeroThrowsOnEveryPath()
+	{
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity1D<double>.FromMeterPerSecond(1) / 0.0);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity3D<double>.FromMeterPerSecond(1, 2, 3) / 0.0);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Mass<double>.FromKilogram(1) / Volume<double>.Zero);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Mass<double>.FromKilogram(0) / Volume<double>.Zero);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity1D<double>.FromMeterPerSecond(1) / Duration<double>.Zero);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity3D<double>.FromMeterPerSecond(1, 2, 3) / Duration<double>.Zero);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity3D<double>.Zero.Normalize());
+	}
+
+	[TestMethod]
+	public void DivisionByZeroThrowsTheSameWayForDecimal()
+	{
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity3D<decimal>.FromMeterPerSecond(1, 2, 3) / 0m);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Mass<decimal>.FromKilogram(1) / Volume<decimal>.Zero);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity3D<decimal>.FromMeterPerSecond(1, 2, 3) / Duration<decimal>.Zero);
+		Assert.ThrowsExactly<DivideByZeroException>(() => Velocity3D<decimal>.Zero.Normalize());
+	}
+}
diff --git a/Semantics.Test/Quantities/StorageMathPreciseAndVectorTests.cs b/Semantics.Test/Quantities/StorageMathPreciseAndVectorTests.cs
new file mode 100644
index 00000000..32eef760
--- /dev/null
+++ b/Semantics.Test/Quantities/StorageMathPreciseAndVectorTests.cs
@@ -0,0 +1,88 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Test.Quantities;
+
+using System.Numerics;
+using ktsu.PreciseNumber;
+using ktsu.Semantics.Quantities;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Higher roots that finish for a type with no fixed precision (#457), and vector lengths that do not
+/// square their components outright (#327).
+/// </summary>
+[TestClass]
+public sealed class StorageMathPreciseAndVectorTests
+{
+	private static PreciseNumber P(double value) => Of<PreciseNumber>(value);
+
+	private static T Of<T>(double value)
+		where T : INumber<T> => T.CreateChecked(value);
+
+	private static T Abs<T>(T value)
+		where T : INumber<T> => T.Abs(value);
+
+	[TestMethod]
+	[Timeout(20_000, CooperativeCancellation = true)]
+	public void PreciseCubeRootOfAPerfectCubeIsExact()
+	{
+		PreciseNumber root = StorageMath.Cbrt(P(27));
+		Assert.IsLessThan(P(1e-30), Abs(root - P(3)));
+	}
+
+	[TestMethod]
+	[Timeout(20_000, CooperativeCancellation = true)]
+	public void PreciseCubeRootOfTwoHasThirtyDigits()
+	{
+		PreciseNumber root = StorageMath.Cbrt(P(2));
+		PreciseNumber error = Abs((root * root * root) - P(2));
+		Assert.IsLessThan(P(1e-30), error);
+	}
+
+	[TestMethod]
+	[Timeout(20_000, CooperativeCancellation = true)]
+	public void PreciseFourthAndFifthRootsFinish()
+	{
+		PreciseNumber fourth = StorageMath.RootN(P(3), 4);
+		PreciseNumber fifth = StorageMath.RootN(P(3), 5);
+
+		Assert.IsLessThan(P(1e-30), Abs((fourth * fourth * fourth * fourth) - P(3)));
+		Assert.IsLessThan(P(1e-30), Abs((fifth * fifth * fifth * fifth * fifth) - P(3)));
+	}
+
+	[TestMethod]
+	public void IntegerVectorLengthsDoNotWrap()
+	{
+		Assert.AreEqual(65536, Position3D<int>.FromMeter(65536, 0, 0).Length());
+		Assert.AreEqual(65536, Displacement2D<int>.FromMeter(65536, 0).Length());
+		Assert.AreEqual(1L << 32, Position3D<long>.FromMeter(1L << 32, 0, 0).Length());
+		Assert.AreEqual(50000, Position3D<int>.FromMeter(50000, 0, 0).Length());
+	}
+
+	[TestMethod]
+	public void DecimalVectorLengthPastTheSquareOfItsRange()
+	{
+		Position3D<decimal> far = Position3D<decimal>.FromMeter(1e15m, 0m, 0m);
+
+		Assert.AreEqual(1e15m, far.Length());
+		Assert.AreEqual(1e15m, far.Magnitude().Value);
+		Assert.AreEqual(1e15m, far.Distance(Position3D<decimal>.Zero));
+	}
+
+	[TestMethod]
+	public void FloatVectorLengthAndNormalizePastTheSquareOfItsRange()
+	{
+		Position3D<float> far = Position3D<float>.FromMeter(1e20f, 0f, 0f);
+
+		Assert.AreEqual(1e20f, far.Length());
+		Assert.AreEqual(1f, far.Normalize().X);
+	}
+
+	[TestMethod]
+	public void FourComponentLengthIsScaled()
+	{
+		Assert.AreEqual(2m, StorageMath.Hypot(1m, 1m, 1m, 1m));
+		Assert.AreEqual(2e20m, StorageMath.Hypot(1e20m, 1e20m, 1e20m, 1e20m));
+		Assert.AreEqual(13d, StorageMath.Hypot(3d, 4d, 12d));
+	}
+}

From f4c9ef7f1b5981d0a4a3bd43ce4161f1c59e1e5f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 10:54:57 +0000
Subject: [PATCH 4/8] [patch] Quantities: overloads forward their base's
 relationship operators (#456)

Distance / Duration, Width * Width, Weight * Height and WindVelocity3D * Duration
now compile. Each overload declares a copy of every relationship operator its
base has with itself on the left; results stay base types.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 .../ActivationEnergy.g.cs                     |   4 +
 .../Admittance.g.cs                           |   4 +
 .../Airspeed.g.cs                             |  28 +++
 .../Altitude.g.cs                             |  40 ++++
 .../ApertureAngle.g.cs                        |   8 +
 .../AtmosphericPressure.g.cs                  |  12 ++
 .../AtomicMass.g.cs                           |  36 ++++
 .../Bandwidth.g.cs                            |   8 +
 .../Bearing.g.cs                              |   4 +
 .../BulkModulus.g.cs                          |  12 ++
 .../Capacity.g.cs                             |  32 +++
 .../ClockSpeed.g.cs                           |   8 +
 .../CrossSectionalArea.g.cs                   |  36 ++++
 .../DecayTime.g.cs                            | 184 ++++++++++++++++++
 .../Depth.g.cs                                |  40 ++++
 .../Diameter.g.cs                             |  40 ++++
 .../Distance.g.cs                             |  40 ++++
 .../Drag.g.cs                                 |  32 +++
 .../EMF.g.cs                                  |  40 ++++
 .../EnergyFluxDensity.g.cs                    |   4 +
 .../EnzymeActivity.g.cs                       |   4 +
 .../FieldOfView.g.cs                          |   8 +
 .../FlowSpeed.g.cs                            |  28 +++
 .../Friction.g.cs                             |  32 +++
 .../Gain.g.cs                                 |  24 +++
 .../GaugePressure.g.cs                        |  12 ++
 .../GravitationalAcceleration.g.cs            |  20 ++
 .../GravitationalField3D.g.cs                 |   6 +
 .../GroundSpeed.g.cs                          |  28 +++
 .../GroupVelocity.g.cs                        |  28 +++
 .../HalfLife.g.cs                             | 184 ++++++++++++++++++
 .../Heading.g.cs                              |   4 +
 .../Heat.g.cs                                 |  40 ++++
 .../HeatCapacity.g.cs                         |  12 ++
 .../HeatFlowRate.g.cs                         |  36 ++++
 .../HeatFlux.g.cs                             |   4 +
 .../Height.g.cs                               |  40 ++++
 .../Impedance.g.cs                            |   8 +
 .../KineticEnergy.g.cs                        |  40 ++++
 .../Latency.g.cs                              | 184 ++++++++++++++++++
 .../Lift.g.cs                                 |  32 +++
 .../MachNumber.g.cs                           |  24 +++
 .../MolarEnthalpy.g.cs                        |   4 +
 .../NoiseReductionCoefficient.g.cs            |  24 +++
 .../NormalForce.g.cs                          |  32 +++
 .../Offset.g.cs                               |   4 +
 .../Perimeter.g.cs                            |  40 ++++
 .../Period.g.cs                               | 184 ++++++++++++++++++
 .../Phase.g.cs                                |   4 +
 .../PhaseVelocity.g.cs                        |  28 +++
 .../Pitch.g.cs                                |   8 +
 .../Position3D.g.cs                           |   3 +
 .../PotentialEnergy.g.cs                      |  40 ++++
 .../Radius.g.cs                               |  40 ++++
 .../ReflectionCoefficient.g.cs                |   8 +
 .../RefractiveIndex.g.cs                      |  24 +++
 .../ReverberationTime.g.cs                    | 184 ++++++++++++++++++
 .../ReynoldsNumber.g.cs                       |  24 +++
 .../Rotation.g.cs                             |   4 +
 .../SamplingRate.g.cs                         |   8 +
 .../ShearModulus.g.cs                         |  12 ++
 .../SoundAbsorption.g.cs                      |  24 +++
 .../SoundIntensity.g.cs                       |   4 +
 .../SoundPower.g.cs                           |  36 ++++
 .../SoundPressure.g.cs                        |  12 ++
 .../SoundSpeed.g.cs                           |  28 +++
 .../SoundTransmissionClass.g.cs               |  24 +++
 .../SpecificEntropy.g.cs                      |   4 +
 .../SpecificGravity.g.cs                      |  24 +++
 .../SpecificKineticEnergy.g.cs                |   4 +
 .../StandardGravitationalParameter.g.cs       |   8 +
 .../Stress.g.cs                               |  12 ++
 .../SurfaceArea.g.cs                          |  36 ++++
 .../Tension.g.cs                              |  32 +++
 .../ThermalDiffusivity.g.cs                   |   4 +
 .../ThermalEnergy.g.cs                        |  40 ++++
 .../Thickness.g.cs                            |  40 ++++
 .../Thrust.g.cs                               |  32 +++
 .../ThrustVector.g.cs                         |   3 +
 .../TimeConstant.g.cs                         | 184 ++++++++++++++++++
 .../Translation3D.g.cs                        |   3 +
 .../VoltageDrop.g.cs                          |  40 ++++
 .../Wavelength.g.cs                           |  40 ++++
 .../Weight.g.cs                               |  32 +++
 .../WeightVector.g.cs                         |   3 +
 .../Width.g.cs                                |  40 ++++
 .../WindSpeed.g.cs                            |  28 +++
 .../WindVelocity3D.g.cs                       |   6 +
 .../Work.g.cs                                 |  40 ++++
 .../YoungsModulus.g.cs                        |  12 ++
 .../Generators/QuantitiesGenerator.cs         |  63 ++++++
 .../GeneratorOutputInvariantTests.cs          |  18 +-
 .../OverloadRelationshipOperatorTests.cs      |  68 +++++++
 docs/migration-guide-2.0.md                   |   5 +-
 docs/physics-generator.md                     |   3 +-
 docs/strategy-unified-vector-quantities.md    |   8 +-
 96 files changed, 3037 insertions(+), 8 deletions(-)
 create mode 100644 Semantics.Test/Quantities/OverloadRelationshipOperatorTests.cs

diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs
index 2a2f6607..f5fad16d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ActivationEnergy.g.cs
@@ -134,5 +134,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ActivationEnergy values, returning the absolute difference as a non-negative ActivationEnergy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ActivationEnergy<T> operator -(ActivationEnergy<T> left, ActivationEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ActivationEnergy * AmountOfSubstance = Energy, through <see cref="MolarEnergy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(ActivationEnergy<T> left, AmountOfSubstance<T> right) => (MolarEnergy<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs
index 9f431079..ce892bc8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Admittance.g.cs
@@ -118,5 +118,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Admittance values, returning the absolute difference as a non-negative Admittance.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Admittance<T> operator -(Admittance<T> left, Admittance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Admittance * VoltageMagnitude = CurrentMagnitude, through <see cref="Conductance{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator *(Admittance<T> left, VoltageMagnitude<T> right) => (Conductance<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs
index ad1418b1..f4bcf115 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Airspeed.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Airspeed values, returning the absolute difference as a non-negative Airspeed.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Airspeed<T> operator -(Airspeed<T> left, Airspeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Airspeed * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Airspeed<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>Airspeed * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(Airspeed<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>Airspeed / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Airspeed<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>Airspeed / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Airspeed<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>Airspeed / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(Airspeed<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>Airspeed / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Airspeed<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>Airspeed * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Airspeed<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs
index daca6559..3fab1ea4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Altitude.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Altitude values, returning the absolute difference as a non-negative Altitude.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Altitude<T> operator -(Altitude<T> left, Altitude<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Altitude * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Altitude<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Altitude<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Altitude<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Altitude / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Altitude<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Altitude * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Altitude<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Altitude<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Altitude<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Altitude<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Altitude<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Altitude * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Altitude<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs
index 00d656ae..e17b072e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ApertureAngle.g.cs
@@ -150,5 +150,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ApertureAngle values, returning the absolute difference as a non-negative ApertureAngle.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ApertureAngle<T> operator -(ApertureAngle<T> left, ApertureAngle<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ApertureAngle / Duration = AngularSpeed, through <see cref="Angle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator /(ApertureAngle<T> left, Duration<T> right) => (Angle<T>)left / right;
+
+	/// <summary>ApertureAngle / AngularSpeed = Duration, through <see cref="Angle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(ApertureAngle<T> left, AngularSpeed<T> right) => (Angle<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs
index 2f318332..bec8138b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtmosphericPressure.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two AtmosphericPressure values, returning the absolute difference as a non-negative AtmosphericPressure.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AtmosphericPressure<T> operator -(AtmosphericPressure<T> left, AtmosphericPressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>AtmosphericPressure * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(AtmosphericPressure<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>AtmosphericPressure * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(AtmosphericPressure<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>AtmosphericPressure * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(AtmosphericPressure<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs
index 4707aea7..97428902 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AtomicMass.g.cs
@@ -174,5 +174,41 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two AtomicMass values, returning the absolute difference as a non-negative AtomicMass.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AtomicMass<T> operator -(AtomicMass<T> left, AtomicMass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>AtomicMass * AccelerationMagnitude = ForceMagnitude, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(AtomicMass<T> left, AccelerationMagnitude<T> right) => (Mass<T>)left * right;
+
+	/// <summary>AtomicMass * Speed = MomentumMagnitude, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(AtomicMass<T> left, Speed<T> right) => (Mass<T>)left * right;
+
+	/// <summary>AtomicMass / Volume = Density, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Density<T> operator /(AtomicMass<T> left, Volume<T> right) => (Mass<T>)left / right;
+
+	/// <summary>AtomicMass / Density = Volume, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(AtomicMass<T> left, Density<T> right) => (Mass<T>)left / right;
+
+	/// <summary>AtomicMass * SpecificHeat = Entropy, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator *(AtomicMass<T> left, SpecificHeat<T> right) => (Mass<T>)left * right;
+
+	/// <summary>AtomicMass / Duration = MassFlowRate, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MassFlowRate<T> operator /(AtomicMass<T> left, Duration<T> right) => (Mass<T>)left / right;
+
+	/// <summary>AtomicMass / MassFlowRate = Duration, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(AtomicMass<T> left, MassFlowRate<T> right) => (Mass<T>)left / right;
+
+	/// <summary>AtomicMass / AmountOfSubstance = MolarMass, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarMass<T> operator /(AtomicMass<T> left, AmountOfSubstance<T> right) => (Mass<T>)left / right;
+
+	/// <summary>AtomicMass / MolarMass = AmountOfSubstance, through <see cref="Mass{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(AtomicMass<T> left, MolarMass<T> right) => (Mass<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs
index 487d02ef..c2679902 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bandwidth.g.cs
@@ -134,5 +134,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Bandwidth values, returning the absolute difference as a non-negative Bandwidth.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Bandwidth<T> operator -(Bandwidth<T> left, Bandwidth<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Bandwidth * Duration = Ratio, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Bandwidth<T> left, Duration<T> right) => (Frequency<T>)left * right;
+
+	/// <summary>Bandwidth * Length = Speed, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Bandwidth<T> left, Length<T> right) => (Frequency<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs
index c9f710bd..9b244283 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Bearing.g.cs
@@ -149,5 +149,9 @@ namespace ktsu.Semantics.Quantities;
 
 	/// <summary>Creates a Bearing from a SignedAngle value.</summary>
 	public static Bearing<T> From(SignedAngle<T> value) => Create(value.Value);
+
+	/// <summary>Bearing / Duration = AngularVelocity1D, through <see cref="SignedAngle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator /(Bearing<T> left, Duration<T> right) => (SignedAngle<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs
index 658b561a..d19f2051 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/BulkModulus.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two BulkModulus values, returning the absolute difference as a non-negative BulkModulus.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static BulkModulus<T> operator -(BulkModulus<T> left, BulkModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>BulkModulus * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(BulkModulus<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>BulkModulus * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(BulkModulus<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>BulkModulus * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(BulkModulus<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs
index 25c1751f..d9c5dae4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacity.g.cs
@@ -198,5 +198,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Capacity values, returning the absolute difference as a non-negative Capacity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Capacity<T> operator -(Capacity<T> left, Capacity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Capacity / Length = Area, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(Capacity<T> left, Length<T> right) => (Volume<T>)left / right;
+
+	/// <summary>Capacity / Area = Length, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Capacity<T> left, Area<T> right) => (Volume<T>)left / right;
+
+	/// <summary>Capacity * Pressure = Energy, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Capacity<T> left, Pressure<T> right) => (Volume<T>)left * right;
+
+	/// <summary>Capacity * Density = Mass, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(Capacity<T> left, Density<T> right) => (Volume<T>)left * right;
+
+	/// <summary>Capacity * Concentration = AmountOfSubstance, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(Capacity<T> left, Concentration<T> right) => (Volume<T>)left * right;
+
+	/// <summary>Capacity / Duration = VolumetricFlowRate, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VolumetricFlowRate<T> operator /(Capacity<T> left, Duration<T> right) => (Volume<T>)left / right;
+
+	/// <summary>Capacity / VolumetricFlowRate = Duration, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Capacity<T> left, VolumetricFlowRate<T> right) => (Volume<T>)left / right;
+
+	/// <summary>Capacity * ElectricPowerDensity = Power, through <see cref="Volume{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Capacity<T> left, ElectricPowerDensity<T> right) => (Volume<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs
index 7b5f4ea4..79d398b6 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ClockSpeed.g.cs
@@ -134,5 +134,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ClockSpeed values, returning the absolute difference as a non-negative ClockSpeed.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ClockSpeed<T> operator -(ClockSpeed<T> left, ClockSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ClockSpeed * Duration = Ratio, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(ClockSpeed<T> left, Duration<T> right) => (Frequency<T>)left * right;
+
+	/// <summary>ClockSpeed * Length = Speed, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(ClockSpeed<T> left, Length<T> right) => (Frequency<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs
index dacce608..f7e3b5e0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CrossSectionalArea.g.cs
@@ -174,5 +174,41 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two CrossSectionalArea values, returning the absolute difference as a non-negative CrossSectionalArea.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static CrossSectionalArea<T> operator -(CrossSectionalArea<T> left, CrossSectionalArea<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>CrossSectionalArea / Length = Length, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(CrossSectionalArea<T> left, Length<T> right) => (Area<T>)left / right;
+
+	/// <summary>CrossSectionalArea * Length = Volume, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(CrossSectionalArea<T> left, Length<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * Pressure = ForceMagnitude, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(CrossSectionalArea<T> left, Pressure<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * ElectricFieldMagnitude = ElectricFlux, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFlux<T> operator *(CrossSectionalArea<T> left, ElectricFieldMagnitude<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * Illuminance = LuminousFlux, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousFlux<T> operator *(CrossSectionalArea<T> left, Illuminance<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * MagneticFluxDensityMagnitude = MagneticFlux, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(CrossSectionalArea<T> left, MagneticFluxDensityMagnitude<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * Irradiance = Power, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(CrossSectionalArea<T> left, Irradiance<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * Luminance = LuminousIntensity, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousIntensity<T> operator *(CrossSectionalArea<T> left, Luminance<T> right) => (Area<T>)left * right;
+
+	/// <summary>CrossSectionalArea * AccelerationMagnitude = GravitationalParameter, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(CrossSectionalArea<T> left, AccelerationMagnitude<T> right) => (Area<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs
index 355641c1..8af06c67 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/DecayTime.g.cs
@@ -182,5 +182,189 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two DecayTime values, returning the absolute difference as a non-negative DecayTime.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static DecayTime<T> operator -(DecayTime<T> left, DecayTime<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>DecayTime * CurrentMagnitude = ChargeMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(DecayTime<T> left, CurrentMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Current1D = Charge, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(DecayTime<T> left, Current1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Speed = Length, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(DecayTime<T> left, Speed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Velocity1D = Displacement1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(DecayTime<T> left, Velocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Velocity2D = Displacement2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(DecayTime<T> left, Velocity2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Velocity3D = Displacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(DecayTime<T> left, Velocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Velocity4D = Displacement4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(DecayTime<T> left, Velocity4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AccelerationMagnitude = Speed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(DecayTime<T> left, AccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Acceleration1D = Velocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(DecayTime<T> left, Acceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Acceleration2D = Velocity2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(DecayTime<T> left, Acceleration2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Acceleration3D = Velocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(DecayTime<T> left, Acceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Acceleration4D = Velocity4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(DecayTime<T> left, Acceleration4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * JerkMagnitude = AccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(DecayTime<T> left, JerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Jerk1D = Acceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(DecayTime<T> left, Jerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Jerk2D = Acceleration2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(DecayTime<T> left, Jerk2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Jerk3D = Acceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(DecayTime<T> left, Jerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Jerk4D = Acceleration4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(DecayTime<T> left, Jerk4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * SnapMagnitude = JerkMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(DecayTime<T> left, SnapMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Snap1D = Jerk1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(DecayTime<T> left, Snap1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Snap2D = Jerk2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(DecayTime<T> left, Snap2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Snap3D = Jerk3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(DecayTime<T> left, Snap3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Snap4D = Jerk4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(DecayTime<T> left, Snap4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Frequency = Ratio, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(DecayTime<T> left, Frequency<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularSpeed = Angle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(DecayTime<T> left, AngularSpeed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularVelocity1D = SignedAngle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(DecayTime<T> left, AngularVelocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularVelocity3D = AngularDisplacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(DecayTime<T> left, AngularVelocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularAccelerationMagnitude = AngularSpeed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(DecayTime<T> left, AngularAccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularAcceleration1D = AngularVelocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(DecayTime<T> left, AngularAcceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularAcceleration3D = AngularVelocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(DecayTime<T> left, AngularAcceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularJerkMagnitude = AngularAccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(DecayTime<T> left, AngularJerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularJerk1D = AngularAcceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(DecayTime<T> left, AngularJerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * AngularJerk3D = AngularAcceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(DecayTime<T> left, AngularJerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * TorqueMagnitude = AngularMomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(DecayTime<T> left, TorqueMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Torque1D = AngularMomentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(DecayTime<T> left, Torque1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Torque3D = AngularMomentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(DecayTime<T> left, Torque3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * ForceMagnitude = MomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(DecayTime<T> left, ForceMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Force1D = Momentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(DecayTime<T> left, Force1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Force2D = Momentum2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(DecayTime<T> left, Force2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Force3D = Momentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(DecayTime<T> left, Force3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Force4D = Momentum4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(DecayTime<T> left, Force4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * Power = Energy, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(DecayTime<T> left, Power<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * VolumetricFlowRate = Volume, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(DecayTime<T> left, VolumetricFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * MassFlowRate = Mass, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(DecayTime<T> left, MassFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * CatalyticActivity = AmountOfSubstance, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(DecayTime<T> left, CatalyticActivity<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * ReactionRate = Concentration, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(DecayTime<T> left, ReactionRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>DecayTime * VoltageMagnitude = MagneticFlux, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(DecayTime<T> left, VoltageMagnitude<T> right) => (Duration<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs
index 965da4c7..23ec5078 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Depth.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Depth values, returning the absolute difference as a non-negative Depth.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Depth<T> operator -(Depth<T> left, Depth<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Depth * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Depth<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Depth<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Depth<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Depth / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Depth<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Depth * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Depth<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Depth<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Depth<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Depth<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Depth<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Depth * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Depth<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs
index 0ddbc05c..46177401 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Diameter.g.cs
@@ -207,6 +207,46 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Diameter<T> operator -(Diameter<T> left, Diameter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
 
+	/// <summary>Diameter * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Diameter<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Diameter<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Diameter<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Diameter / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Diameter<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Diameter * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Diameter<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Diameter<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Diameter<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Diameter<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Diameter<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Diameter * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Diameter<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
+
 	/// <summary>Converts this Diameter to a Radius.</summary>
 	public Radius<T> ToRadius() => Radius<T>.Create(Value / T.CreateChecked(2));
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs
index 19b09266..74180f16 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Distance.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Distance values, returning the absolute difference as a non-negative Distance.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Distance<T> operator -(Distance<T> left, Distance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Distance * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Distance<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Distance<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Distance<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Distance / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Distance<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Distance * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Distance<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Distance<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Distance<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Distance<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Distance<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Distance * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Distance<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs
index 7dd178e5..10676146 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Drag.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Drag values, returning the absolute difference as a non-negative Drag.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Drag<T> operator -(Drag<T> left, Drag<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Drag / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Drag<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Drag / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Drag<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Drag * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Drag<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Drag * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Drag<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Drag * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Drag<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Drag / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Drag<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Drag / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(Drag<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Drag / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Drag<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs
index e8e2a2a8..089582b1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EMF.g.cs
@@ -126,5 +126,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two EMF values, returning the absolute difference as a non-negative EMF.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static EMF<T> operator -(EMF<T> left, EMF<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>EMF / Resistance = CurrentMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(EMF<T> left, Resistance<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>EMF / CurrentMagnitude = Resistance, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Resistance<T> operator /(EMF<T> left, CurrentMagnitude<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>EMF * CurrentMagnitude = Power, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(EMF<T> left, CurrentMagnitude<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>EMF / Length = ElectricFieldMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFieldMagnitude<T> operator /(EMF<T> left, Length<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>EMF / ElectricFieldMagnitude = Length, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(EMF<T> left, ElectricFieldMagnitude<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>EMF * Capacitance = ChargeMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(EMF<T> left, Capacitance<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>EMF * Conductance = CurrentMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator *(EMF<T> left, Conductance<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>EMF * Duration = MagneticFlux, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(EMF<T> left, Duration<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>EMF / Pressure = Sensitivity, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Sensitivity<T> operator /(EMF<T> left, Pressure<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>EMF / Sensitivity = Pressure, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(EMF<T> left, Sensitivity<T> right) => (VoltageMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs
index 84643bcd..97fa3ea0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnergyFluxDensity.g.cs
@@ -118,5 +118,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two EnergyFluxDensity values, returning the absolute difference as a non-negative EnergyFluxDensity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static EnergyFluxDensity<T> operator -(EnergyFluxDensity<T> left, EnergyFluxDensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>EnergyFluxDensity * Area = Power, through <see cref="Irradiance{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(EnergyFluxDensity<T> left, Area<T> right) => (Irradiance<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs
index fe485d3b..a0f34ca4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EnzymeActivity.g.cs
@@ -126,5 +126,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two EnzymeActivity values, returning the absolute difference as a non-negative EnzymeActivity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static EnzymeActivity<T> operator -(EnzymeActivity<T> left, EnzymeActivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>EnzymeActivity * Duration = AmountOfSubstance, through <see cref="CatalyticActivity{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(EnzymeActivity<T> left, Duration<T> right) => (CatalyticActivity<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs
index fa8435ee..36a68f87 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FieldOfView.g.cs
@@ -150,5 +150,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two FieldOfView values, returning the absolute difference as a non-negative FieldOfView.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static FieldOfView<T> operator -(FieldOfView<T> left, FieldOfView<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>FieldOfView / Duration = AngularSpeed, through <see cref="Angle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator /(FieldOfView<T> left, Duration<T> right) => (Angle<T>)left / right;
+
+	/// <summary>FieldOfView / AngularSpeed = Duration, through <see cref="Angle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(FieldOfView<T> left, AngularSpeed<T> right) => (Angle<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs
index c377864a..a46338c8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/FlowSpeed.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two FlowSpeed values, returning the absolute difference as a non-negative FlowSpeed.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static FlowSpeed<T> operator -(FlowSpeed<T> left, FlowSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>FlowSpeed * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(FlowSpeed<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>FlowSpeed * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(FlowSpeed<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>FlowSpeed / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(FlowSpeed<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>FlowSpeed / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(FlowSpeed<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>FlowSpeed / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(FlowSpeed<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>FlowSpeed / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(FlowSpeed<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>FlowSpeed * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(FlowSpeed<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs
index fb04af6b..bdce8d5f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Friction.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Friction values, returning the absolute difference as a non-negative Friction.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Friction<T> operator -(Friction<T> left, Friction<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Friction / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Friction<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Friction / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Friction<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Friction * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Friction<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Friction * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Friction<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Friction * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Friction<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Friction / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Friction<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Friction / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(Friction<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Friction / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Friction<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs
index d21d72a3..491cf06a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Gain.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Gain values, returning the absolute difference as a non-negative Gain.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Gain<T> operator -(Gain<T> left, Gain<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Gain * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Gain<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>Gain * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(Gain<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>Gain / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(Gain<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>Gain / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Gain<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>Gain / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(Gain<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>Gain / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(Gain<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs
index 38b9b172..50046f7f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GaugePressure.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two GaugePressure values, returning the absolute difference as a non-negative GaugePressure.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static GaugePressure<T> operator -(GaugePressure<T> left, GaugePressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>GaugePressure * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(GaugePressure<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>GaugePressure * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(GaugePressure<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>GaugePressure * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(GaugePressure<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs
index 0e23edf7..aabb5ad8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalAcceleration.g.cs
@@ -126,5 +126,25 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two GravitationalAcceleration values, returning the absolute difference as a non-negative GravitationalAcceleration.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static GravitationalAcceleration<T> operator -(GravitationalAcceleration<T> left, GravitationalAcceleration<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>GravitationalAcceleration * Mass = ForceMagnitude, through <see cref="AccelerationMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(GravitationalAcceleration<T> left, Mass<T> right) => (AccelerationMagnitude<T>)left * right;
+
+	/// <summary>GravitationalAcceleration * Duration = Speed, through <see cref="AccelerationMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(GravitationalAcceleration<T> left, Duration<T> right) => (AccelerationMagnitude<T>)left * right;
+
+	/// <summary>GravitationalAcceleration / Duration = JerkMagnitude, through <see cref="AccelerationMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator /(GravitationalAcceleration<T> left, Duration<T> right) => (AccelerationMagnitude<T>)left / right;
+
+	/// <summary>GravitationalAcceleration / JerkMagnitude = Duration, through <see cref="AccelerationMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(GravitationalAcceleration<T> left, JerkMagnitude<T> right) => (AccelerationMagnitude<T>)left / right;
+
+	/// <summary>GravitationalAcceleration * Area = GravitationalParameter, through <see cref="AccelerationMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(GravitationalAcceleration<T> left, Area<T> right) => (AccelerationMagnitude<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs
index 6423eb27..d8ea8de6 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GravitationalField3D.g.cs
@@ -132,6 +132,12 @@ public GravitationalField3D<T> Normalize()
 
 	/// <summary>Negates a vector.</summary>
 	public static GravitationalField3D<T> operator -(GravitationalField3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
+	/// <summary>GravitationalField3D * Duration = Velocity3D, through <see cref="Acceleration3D{T}"/>.</summary>
+	public static Velocity3D<T> operator *(GravitationalField3D<T> left, Duration<T> right) => (Acceleration3D<T>)left * right;
+
+	/// <summary>GravitationalField3D / Duration = Jerk3D, through <see cref="Acceleration3D{T}"/>.</summary>
+	public static Jerk3D<T> operator /(GravitationalField3D<T> left, Duration<T> right) => (Acceleration3D<T>)left / right;
+
 	/// <summary>Implicit conversion to Acceleration3D.</summary>
 	public static implicit operator Acceleration3D<T>(GravitationalField3D<T> value) => new() { X = value.X, Y = value.Y, Z = value.Z };
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs
index e74a6c44..5ea8c760 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroundSpeed.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two GroundSpeed values, returning the absolute difference as a non-negative GroundSpeed.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static GroundSpeed<T> operator -(GroundSpeed<T> left, GroundSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>GroundSpeed * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(GroundSpeed<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>GroundSpeed * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(GroundSpeed<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>GroundSpeed / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(GroundSpeed<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroundSpeed / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(GroundSpeed<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroundSpeed / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(GroundSpeed<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroundSpeed / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(GroundSpeed<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroundSpeed * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(GroundSpeed<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs
index 985c2a1a..55fac806 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/GroupVelocity.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two GroupVelocity values, returning the absolute difference as a non-negative GroupVelocity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static GroupVelocity<T> operator -(GroupVelocity<T> left, GroupVelocity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>GroupVelocity * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(GroupVelocity<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>GroupVelocity * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(GroupVelocity<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>GroupVelocity / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(GroupVelocity<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroupVelocity / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(GroupVelocity<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroupVelocity / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(GroupVelocity<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroupVelocity / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(GroupVelocity<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>GroupVelocity * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(GroupVelocity<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
index af1eae3e..a6705434 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
@@ -182,5 +182,189 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two HalfLife values, returning the absolute difference as a positive HalfLife. Throws <see cref="System.ArgumentException"/> when the two are equal, since a HalfLife cannot be zero; widen to <see cref="Duration{T}"/> first for a difference that may be.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static HalfLife<T> operator -(HalfLife<T> left, HalfLife<T> right) => Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));
+
+	/// <summary>HalfLife * CurrentMagnitude = ChargeMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(HalfLife<T> left, CurrentMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Current1D = Charge, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(HalfLife<T> left, Current1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Speed = Length, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(HalfLife<T> left, Speed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Velocity1D = Displacement1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(HalfLife<T> left, Velocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Velocity2D = Displacement2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(HalfLife<T> left, Velocity2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Velocity3D = Displacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(HalfLife<T> left, Velocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Velocity4D = Displacement4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(HalfLife<T> left, Velocity4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AccelerationMagnitude = Speed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(HalfLife<T> left, AccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Acceleration1D = Velocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(HalfLife<T> left, Acceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Acceleration2D = Velocity2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(HalfLife<T> left, Acceleration2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Acceleration3D = Velocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(HalfLife<T> left, Acceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Acceleration4D = Velocity4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(HalfLife<T> left, Acceleration4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * JerkMagnitude = AccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(HalfLife<T> left, JerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Jerk1D = Acceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(HalfLife<T> left, Jerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Jerk2D = Acceleration2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(HalfLife<T> left, Jerk2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Jerk3D = Acceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(HalfLife<T> left, Jerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Jerk4D = Acceleration4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(HalfLife<T> left, Jerk4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * SnapMagnitude = JerkMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(HalfLife<T> left, SnapMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Snap1D = Jerk1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(HalfLife<T> left, Snap1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Snap2D = Jerk2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(HalfLife<T> left, Snap2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Snap3D = Jerk3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(HalfLife<T> left, Snap3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Snap4D = Jerk4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(HalfLife<T> left, Snap4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Frequency = Ratio, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(HalfLife<T> left, Frequency<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularSpeed = Angle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(HalfLife<T> left, AngularSpeed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularVelocity1D = SignedAngle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(HalfLife<T> left, AngularVelocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularVelocity3D = AngularDisplacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(HalfLife<T> left, AngularVelocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularAccelerationMagnitude = AngularSpeed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(HalfLife<T> left, AngularAccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularAcceleration1D = AngularVelocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(HalfLife<T> left, AngularAcceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularAcceleration3D = AngularVelocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(HalfLife<T> left, AngularAcceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularJerkMagnitude = AngularAccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(HalfLife<T> left, AngularJerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularJerk1D = AngularAcceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(HalfLife<T> left, AngularJerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * AngularJerk3D = AngularAcceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(HalfLife<T> left, AngularJerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * TorqueMagnitude = AngularMomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(HalfLife<T> left, TorqueMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Torque1D = AngularMomentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(HalfLife<T> left, Torque1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Torque3D = AngularMomentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(HalfLife<T> left, Torque3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * ForceMagnitude = MomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(HalfLife<T> left, ForceMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Force1D = Momentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(HalfLife<T> left, Force1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Force2D = Momentum2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(HalfLife<T> left, Force2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Force3D = Momentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(HalfLife<T> left, Force3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Force4D = Momentum4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(HalfLife<T> left, Force4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * Power = Energy, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(HalfLife<T> left, Power<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * VolumetricFlowRate = Volume, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(HalfLife<T> left, VolumetricFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * MassFlowRate = Mass, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(HalfLife<T> left, MassFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * CatalyticActivity = AmountOfSubstance, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(HalfLife<T> left, CatalyticActivity<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * ReactionRate = Concentration, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(HalfLife<T> left, ReactionRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>HalfLife * VoltageMagnitude = MagneticFlux, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(HalfLife<T> left, VoltageMagnitude<T> right) => (Duration<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs
index 2b71481b..2df194c8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heading.g.cs
@@ -149,5 +149,9 @@ namespace ktsu.Semantics.Quantities;
 
 	/// <summary>Creates a Heading from a SignedAngle value.</summary>
 	public static Heading<T> From(SignedAngle<T> value) => Create(value.Value);
+
+	/// <summary>Heading / Duration = AngularVelocity1D, through <see cref="SignedAngle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator /(Heading<T> left, Duration<T> right) => (SignedAngle<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs
index 4089fa64..f5581828 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Heat.g.cs
@@ -182,5 +182,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Heat values, returning the absolute difference as a non-negative Heat.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Heat<T> operator -(Heat<T> left, Heat<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Heat / Length = ForceMagnitude, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(Heat<T> left, Length<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / ForceMagnitude = Length, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Heat<T> left, ForceMagnitude<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / Volume = Pressure, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Heat<T> left, Volume<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / Pressure = Volume, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(Heat<T> left, Pressure<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / Duration = Power, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator /(Heat<T> left, Duration<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / Power = Duration, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Heat<T> left, Power<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / Temperature = Entropy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator /(Heat<T> left, Temperature<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / Entropy = Temperature, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(Heat<T> left, Entropy<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / AmountOfSubstance = MolarEnergy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator /(Heat<T> left, AmountOfSubstance<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Heat / MolarEnergy = AmountOfSubstance, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(Heat<T> left, MolarEnergy<T> right) => (Energy<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs
index 0e2ddf0d..67fbdd11 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatCapacity.g.cs
@@ -118,5 +118,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two HeatCapacity values, returning the absolute difference as a non-negative HeatCapacity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static HeatCapacity<T> operator -(HeatCapacity<T> left, HeatCapacity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>HeatCapacity * Temperature = Energy, through <see cref="Entropy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(HeatCapacity<T> left, Temperature<T> right) => (Entropy<T>)left * right;
+
+	/// <summary>HeatCapacity / Mass = SpecificHeat, through <see cref="Entropy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SpecificHeat<T> operator /(HeatCapacity<T> left, Mass<T> right) => (Entropy<T>)left / right;
+
+	/// <summary>HeatCapacity / SpecificHeat = Mass, through <see cref="Entropy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(HeatCapacity<T> left, SpecificHeat<T> right) => (Entropy<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs
index a7686c86..02a2bab1 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlowRate.g.cs
@@ -142,5 +142,41 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two HeatFlowRate values, returning the absolute difference as a non-negative HeatFlowRate.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static HeatFlowRate<T> operator -(HeatFlowRate<T> left, HeatFlowRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>HeatFlowRate / VoltageMagnitude = CurrentMagnitude, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(HeatFlowRate<T> left, VoltageMagnitude<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate / CurrentMagnitude = VoltageMagnitude, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator /(HeatFlowRate<T> left, CurrentMagnitude<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate / Speed = ForceMagnitude, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(HeatFlowRate<T> left, Speed<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate / ForceMagnitude = Speed, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(HeatFlowRate<T> left, ForceMagnitude<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate * Duration = Energy, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(HeatFlowRate<T> left, Duration<T> right) => (Power<T>)left * right;
+
+	/// <summary>HeatFlowRate / Area = Irradiance, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Irradiance<T> operator /(HeatFlowRate<T> left, Area<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate / Irradiance = Area, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(HeatFlowRate<T> left, Irradiance<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate / Volume = ElectricPowerDensity, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricPowerDensity<T> operator /(HeatFlowRate<T> left, Volume<T> right) => (Power<T>)left / right;
+
+	/// <summary>HeatFlowRate / ElectricPowerDensity = Volume, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(HeatFlowRate<T> left, ElectricPowerDensity<T> right) => (Power<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs
index 13e91bc8..7092a019 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatFlux.g.cs
@@ -118,5 +118,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two HeatFlux values, returning the absolute difference as a non-negative HeatFlux.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static HeatFlux<T> operator -(HeatFlux<T> left, HeatFlux<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>HeatFlux * Area = Power, through <see cref="Irradiance{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(HeatFlux<T> left, Area<T> right) => (Irradiance<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs
index 87914521..1f2038cc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Height.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Height values, returning the absolute difference as a non-negative Height.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Height<T> operator -(Height<T> left, Height<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Height * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Height<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Height<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Height<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Height / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Height<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Height * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Height<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Height<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Height<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Height<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Height<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Height * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Height<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs
index 752715f4..0f55417c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Impedance.g.cs
@@ -134,5 +134,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Impedance values, returning the absolute difference as a non-negative Impedance.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Impedance<T> operator -(Impedance<T> left, Impedance<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Impedance * CurrentMagnitude = VoltageMagnitude, through <see cref="Resistance{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Impedance<T> left, CurrentMagnitude<T> right) => (Resistance<T>)left * right;
+
+	/// <summary>Impedance * Current1D = Voltage, through <see cref="Resistance{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Impedance<T> left, Current1D<T> right) => (Resistance<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs
index a6e06f84..fbcf7daa 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KineticEnergy.g.cs
@@ -182,5 +182,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two KineticEnergy values, returning the absolute difference as a non-negative KineticEnergy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static KineticEnergy<T> operator -(KineticEnergy<T> left, KineticEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>KineticEnergy / Length = ForceMagnitude, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(KineticEnergy<T> left, Length<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / ForceMagnitude = Length, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(KineticEnergy<T> left, ForceMagnitude<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / Volume = Pressure, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(KineticEnergy<T> left, Volume<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / Pressure = Volume, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(KineticEnergy<T> left, Pressure<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / Duration = Power, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator /(KineticEnergy<T> left, Duration<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / Power = Duration, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(KineticEnergy<T> left, Power<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / Temperature = Entropy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator /(KineticEnergy<T> left, Temperature<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / Entropy = Temperature, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(KineticEnergy<T> left, Entropy<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / AmountOfSubstance = MolarEnergy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator /(KineticEnergy<T> left, AmountOfSubstance<T> right) => (Energy<T>)left / right;
+
+	/// <summary>KineticEnergy / MolarEnergy = AmountOfSubstance, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(KineticEnergy<T> left, MolarEnergy<T> right) => (Energy<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs
index f5940e85..e5a39d6f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Latency.g.cs
@@ -182,5 +182,189 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Latency values, returning the absolute difference as a non-negative Latency.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Latency<T> operator -(Latency<T> left, Latency<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Latency * CurrentMagnitude = ChargeMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(Latency<T> left, CurrentMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Current1D = Charge, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(Latency<T> left, Current1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Speed = Length, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(Latency<T> left, Speed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Velocity1D = Displacement1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(Latency<T> left, Velocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Velocity2D = Displacement2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(Latency<T> left, Velocity2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Velocity3D = Displacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(Latency<T> left, Velocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Velocity4D = Displacement4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(Latency<T> left, Velocity4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AccelerationMagnitude = Speed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Latency<T> left, AccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Acceleration1D = Velocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(Latency<T> left, Acceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Acceleration2D = Velocity2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(Latency<T> left, Acceleration2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Acceleration3D = Velocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(Latency<T> left, Acceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Acceleration4D = Velocity4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(Latency<T> left, Acceleration4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * JerkMagnitude = AccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(Latency<T> left, JerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Jerk1D = Acceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(Latency<T> left, Jerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Jerk2D = Acceleration2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(Latency<T> left, Jerk2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Jerk3D = Acceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(Latency<T> left, Jerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Jerk4D = Acceleration4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(Latency<T> left, Jerk4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * SnapMagnitude = JerkMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(Latency<T> left, SnapMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Snap1D = Jerk1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(Latency<T> left, Snap1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Snap2D = Jerk2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(Latency<T> left, Snap2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Snap3D = Jerk3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(Latency<T> left, Snap3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Snap4D = Jerk4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(Latency<T> left, Snap4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Frequency = Ratio, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Latency<T> left, Frequency<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularSpeed = Angle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(Latency<T> left, AngularSpeed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularVelocity1D = SignedAngle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(Latency<T> left, AngularVelocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularVelocity3D = AngularDisplacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(Latency<T> left, AngularVelocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularAccelerationMagnitude = AngularSpeed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(Latency<T> left, AngularAccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularAcceleration1D = AngularVelocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(Latency<T> left, AngularAcceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularAcceleration3D = AngularVelocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(Latency<T> left, AngularAcceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularJerkMagnitude = AngularAccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(Latency<T> left, AngularJerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularJerk1D = AngularAcceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(Latency<T> left, AngularJerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * AngularJerk3D = AngularAcceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(Latency<T> left, AngularJerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * TorqueMagnitude = AngularMomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(Latency<T> left, TorqueMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Torque1D = AngularMomentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(Latency<T> left, Torque1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Torque3D = AngularMomentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(Latency<T> left, Torque3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * ForceMagnitude = MomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Latency<T> left, ForceMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Force1D = Momentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(Latency<T> left, Force1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Force2D = Momentum2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(Latency<T> left, Force2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Force3D = Momentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(Latency<T> left, Force3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Force4D = Momentum4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(Latency<T> left, Force4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * Power = Energy, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Latency<T> left, Power<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * VolumetricFlowRate = Volume, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Latency<T> left, VolumetricFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * MassFlowRate = Mass, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(Latency<T> left, MassFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * CatalyticActivity = AmountOfSubstance, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(Latency<T> left, CatalyticActivity<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * ReactionRate = Concentration, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(Latency<T> left, ReactionRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Latency * VoltageMagnitude = MagneticFlux, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(Latency<T> left, VoltageMagnitude<T> right) => (Duration<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs
index 46aa4a36..d9731faa 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Lift.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Lift values, returning the absolute difference as a non-negative Lift.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Lift<T> operator -(Lift<T> left, Lift<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Lift / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Lift<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Lift / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Lift<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Lift * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Lift<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Lift * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Lift<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Lift * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Lift<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Lift / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Lift<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Lift / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(Lift<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Lift / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Lift<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs
index 8e4f5396..816efbe0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MachNumber.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two MachNumber values, returning the absolute difference as a non-negative MachNumber.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MachNumber<T> operator -(MachNumber<T> left, MachNumber<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>MachNumber * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(MachNumber<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>MachNumber * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(MachNumber<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>MachNumber / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(MachNumber<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>MachNumber / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(MachNumber<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>MachNumber / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(MachNumber<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>MachNumber / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(MachNumber<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs
index babe0b52..575ae108 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnthalpy.g.cs
@@ -134,5 +134,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two MolarEnthalpy values, returning the absolute difference as a non-negative MolarEnthalpy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MolarEnthalpy<T> operator -(MolarEnthalpy<T> left, MolarEnthalpy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>MolarEnthalpy * AmountOfSubstance = Energy, through <see cref="MolarEnergy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(MolarEnthalpy<T> left, AmountOfSubstance<T> right) => (MolarEnergy<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs
index 125829ff..6776ba92 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NoiseReductionCoefficient.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two NoiseReductionCoefficient values, returning the absolute difference as a non-negative NoiseReductionCoefficient.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static NoiseReductionCoefficient<T> operator -(NoiseReductionCoefficient<T> left, NoiseReductionCoefficient<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>NoiseReductionCoefficient * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(NoiseReductionCoefficient<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>NoiseReductionCoefficient * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(NoiseReductionCoefficient<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>NoiseReductionCoefficient / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(NoiseReductionCoefficient<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>NoiseReductionCoefficient / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(NoiseReductionCoefficient<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>NoiseReductionCoefficient / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(NoiseReductionCoefficient<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>NoiseReductionCoefficient / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(NoiseReductionCoefficient<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs
index 8de8ed84..8d59c894 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NormalForce.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two NormalForce values, returning the absolute difference as a non-negative NormalForce.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static NormalForce<T> operator -(NormalForce<T> left, NormalForce<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>NormalForce / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(NormalForce<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>NormalForce / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(NormalForce<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>NormalForce * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(NormalForce<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>NormalForce * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(NormalForce<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>NormalForce * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(NormalForce<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>NormalForce / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(NormalForce<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>NormalForce / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(NormalForce<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>NormalForce / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(NormalForce<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs
index fc00a0bf..395e4fc2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Offset.g.cs
@@ -198,5 +198,9 @@ namespace ktsu.Semantics.Quantities;
 
 	/// <summary>Creates a Offset from a Displacement1D value.</summary>
 	public static Offset<T> From(Displacement1D<T> value) => Create(value.Value);
+
+	/// <summary>Offset / Duration = Velocity1D, through <see cref="Displacement1D{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator /(Offset<T> left, Duration<T> right) => (Displacement1D<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs
index 0966914a..af9f17be 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Perimeter.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Perimeter values, returning the absolute difference as a non-negative Perimeter.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Perimeter<T> operator -(Perimeter<T> left, Perimeter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Perimeter * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Perimeter<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Perimeter<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Perimeter<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Perimeter / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Perimeter<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Perimeter * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Perimeter<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Perimeter<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Perimeter<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Perimeter<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Perimeter<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Perimeter * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Perimeter<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
index 2e3305bc..ee5733c8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
@@ -182,5 +182,189 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Period values, returning the absolute difference as a positive Period. Throws <see cref="System.ArgumentException"/> when the two are equal, since a Period cannot be zero; widen to <see cref="Duration{T}"/> first for a difference that may be.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Period<T> operator -(Period<T> left, Period<T> right) => Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));
+
+	/// <summary>Period * CurrentMagnitude = ChargeMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(Period<T> left, CurrentMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Current1D = Charge, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(Period<T> left, Current1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Speed = Length, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(Period<T> left, Speed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Velocity1D = Displacement1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(Period<T> left, Velocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Velocity2D = Displacement2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(Period<T> left, Velocity2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Velocity3D = Displacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(Period<T> left, Velocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Velocity4D = Displacement4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(Period<T> left, Velocity4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AccelerationMagnitude = Speed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Period<T> left, AccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Acceleration1D = Velocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(Period<T> left, Acceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Acceleration2D = Velocity2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(Period<T> left, Acceleration2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Acceleration3D = Velocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(Period<T> left, Acceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Acceleration4D = Velocity4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(Period<T> left, Acceleration4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * JerkMagnitude = AccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(Period<T> left, JerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Jerk1D = Acceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(Period<T> left, Jerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Jerk2D = Acceleration2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(Period<T> left, Jerk2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Jerk3D = Acceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(Period<T> left, Jerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Jerk4D = Acceleration4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(Period<T> left, Jerk4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * SnapMagnitude = JerkMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(Period<T> left, SnapMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Snap1D = Jerk1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(Period<T> left, Snap1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Snap2D = Jerk2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(Period<T> left, Snap2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Snap3D = Jerk3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(Period<T> left, Snap3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Snap4D = Jerk4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(Period<T> left, Snap4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Frequency = Ratio, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Period<T> left, Frequency<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularSpeed = Angle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(Period<T> left, AngularSpeed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularVelocity1D = SignedAngle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(Period<T> left, AngularVelocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularVelocity3D = AngularDisplacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(Period<T> left, AngularVelocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularAccelerationMagnitude = AngularSpeed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(Period<T> left, AngularAccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularAcceleration1D = AngularVelocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(Period<T> left, AngularAcceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularAcceleration3D = AngularVelocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(Period<T> left, AngularAcceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularJerkMagnitude = AngularAccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(Period<T> left, AngularJerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularJerk1D = AngularAcceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(Period<T> left, AngularJerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * AngularJerk3D = AngularAcceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(Period<T> left, AngularJerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * TorqueMagnitude = AngularMomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(Period<T> left, TorqueMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Torque1D = AngularMomentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(Period<T> left, Torque1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Torque3D = AngularMomentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(Period<T> left, Torque3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * ForceMagnitude = MomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Period<T> left, ForceMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Force1D = Momentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(Period<T> left, Force1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Force2D = Momentum2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(Period<T> left, Force2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Force3D = Momentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(Period<T> left, Force3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Force4D = Momentum4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(Period<T> left, Force4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * Power = Energy, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Period<T> left, Power<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * VolumetricFlowRate = Volume, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Period<T> left, VolumetricFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * MassFlowRate = Mass, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(Period<T> left, MassFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * CatalyticActivity = AmountOfSubstance, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(Period<T> left, CatalyticActivity<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * ReactionRate = Concentration, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(Period<T> left, ReactionRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>Period * VoltageMagnitude = MagneticFlux, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(Period<T> left, VoltageMagnitude<T> right) => (Duration<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs
index 7d5ce60a..f58e5b14 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Phase.g.cs
@@ -149,5 +149,9 @@ namespace ktsu.Semantics.Quantities;
 
 	/// <summary>Creates a Phase from a SignedAngle value.</summary>
 	public static Phase<T> From(SignedAngle<T> value) => Create(value.Value);
+
+	/// <summary>Phase / Duration = AngularVelocity1D, through <see cref="SignedAngle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator /(Phase<T> left, Duration<T> right) => (SignedAngle<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs
index cb806777..ae16aa43 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PhaseVelocity.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two PhaseVelocity values, returning the absolute difference as a non-negative PhaseVelocity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static PhaseVelocity<T> operator -(PhaseVelocity<T> left, PhaseVelocity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>PhaseVelocity * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(PhaseVelocity<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>PhaseVelocity * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(PhaseVelocity<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>PhaseVelocity / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(PhaseVelocity<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>PhaseVelocity / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(PhaseVelocity<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>PhaseVelocity / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(PhaseVelocity<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>PhaseVelocity / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(PhaseVelocity<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>PhaseVelocity * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(PhaseVelocity<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs
index 4ccf93d4..02f913aa 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pitch.g.cs
@@ -134,5 +134,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Pitch values, returning the absolute difference as a non-negative Pitch.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Pitch<T> operator -(Pitch<T> left, Pitch<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Pitch * Duration = Ratio, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(Pitch<T> left, Duration<T> right) => (Frequency<T>)left * right;
+
+	/// <summary>Pitch * Length = Speed, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Pitch<T> left, Length<T> right) => (Frequency<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs
index b1c46c47..74301c6c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Position3D.g.cs
@@ -202,6 +202,9 @@ public Position3D<T> Normalize()
 
 	/// <summary>Negates a vector.</summary>
 	public static Position3D<T> operator -(Position3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
+	/// <summary>Position3D / Duration = Velocity3D, through <see cref="Displacement3D{T}"/>.</summary>
+	public static Velocity3D<T> operator /(Position3D<T> left, Duration<T> right) => (Displacement3D<T>)left / right;
+
 	/// <summary>Implicit conversion to Displacement3D.</summary>
 	public static implicit operator Displacement3D<T>(Position3D<T> value) => new() { X = value.X, Y = value.Y, Z = value.Z };
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs
index 6027bbb7..421c2729 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/PotentialEnergy.g.cs
@@ -182,5 +182,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two PotentialEnergy values, returning the absolute difference as a non-negative PotentialEnergy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static PotentialEnergy<T> operator -(PotentialEnergy<T> left, PotentialEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>PotentialEnergy / Length = ForceMagnitude, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(PotentialEnergy<T> left, Length<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / ForceMagnitude = Length, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(PotentialEnergy<T> left, ForceMagnitude<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / Volume = Pressure, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(PotentialEnergy<T> left, Volume<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / Pressure = Volume, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(PotentialEnergy<T> left, Pressure<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / Duration = Power, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator /(PotentialEnergy<T> left, Duration<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / Power = Duration, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(PotentialEnergy<T> left, Power<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / Temperature = Entropy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator /(PotentialEnergy<T> left, Temperature<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / Entropy = Temperature, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(PotentialEnergy<T> left, Entropy<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / AmountOfSubstance = MolarEnergy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator /(PotentialEnergy<T> left, AmountOfSubstance<T> right) => (Energy<T>)left / right;
+
+	/// <summary>PotentialEnergy / MolarEnergy = AmountOfSubstance, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(PotentialEnergy<T> left, MolarEnergy<T> right) => (Energy<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs
index 9fb9336a..ac6a3c1e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Radius.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Radius values, returning the absolute difference as a non-negative Radius.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Radius<T> operator -(Radius<T> left, Radius<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Radius * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Radius<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Radius<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Radius<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Radius / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Radius<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Radius * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Radius<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Radius<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Radius<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Radius<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Radius<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Radius * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Radius<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs
index 961da948..a5972740 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReflectionCoefficient.g.cs
@@ -184,5 +184,13 @@ namespace ktsu.Semantics.Quantities;
 
 	/// <summary>Creates a ReflectionCoefficient from a SignedRatio value.</summary>
 	public static ReflectionCoefficient<T> From(SignedRatio<T> value) => Create(value.Value);
+
+	/// <summary>ReflectionCoefficient * Ratio = SignedRatio, through <see cref="SignedRatio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(ReflectionCoefficient<T> left, Ratio<T> right) => (SignedRatio<T>)left * right;
+
+	/// <summary>ReflectionCoefficient / Ratio = SignedRatio, through <see cref="SignedRatio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator /(ReflectionCoefficient<T> left, Ratio<T> right) => (SignedRatio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs
index 56af640b..ca547845 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RefractiveIndex.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two RefractiveIndex values, returning the absolute difference as a non-negative RefractiveIndex.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static RefractiveIndex<T> operator -(RefractiveIndex<T> left, RefractiveIndex<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>RefractiveIndex * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(RefractiveIndex<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>RefractiveIndex * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(RefractiveIndex<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>RefractiveIndex / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(RefractiveIndex<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>RefractiveIndex / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(RefractiveIndex<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>RefractiveIndex / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(RefractiveIndex<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>RefractiveIndex / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(RefractiveIndex<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs
index df76f8b1..65d25c0f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReverberationTime.g.cs
@@ -182,5 +182,189 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ReverberationTime values, returning the absolute difference as a non-negative ReverberationTime.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ReverberationTime<T> operator -(ReverberationTime<T> left, ReverberationTime<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ReverberationTime * CurrentMagnitude = ChargeMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(ReverberationTime<T> left, CurrentMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Current1D = Charge, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(ReverberationTime<T> left, Current1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Speed = Length, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(ReverberationTime<T> left, Speed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Velocity1D = Displacement1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(ReverberationTime<T> left, Velocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Velocity2D = Displacement2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(ReverberationTime<T> left, Velocity2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Velocity3D = Displacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(ReverberationTime<T> left, Velocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Velocity4D = Displacement4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(ReverberationTime<T> left, Velocity4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AccelerationMagnitude = Speed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(ReverberationTime<T> left, AccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Acceleration1D = Velocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(ReverberationTime<T> left, Acceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Acceleration2D = Velocity2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(ReverberationTime<T> left, Acceleration2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Acceleration3D = Velocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(ReverberationTime<T> left, Acceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Acceleration4D = Velocity4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(ReverberationTime<T> left, Acceleration4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * JerkMagnitude = AccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(ReverberationTime<T> left, JerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Jerk1D = Acceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(ReverberationTime<T> left, Jerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Jerk2D = Acceleration2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(ReverberationTime<T> left, Jerk2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Jerk3D = Acceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(ReverberationTime<T> left, Jerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Jerk4D = Acceleration4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(ReverberationTime<T> left, Jerk4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * SnapMagnitude = JerkMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(ReverberationTime<T> left, SnapMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Snap1D = Jerk1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(ReverberationTime<T> left, Snap1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Snap2D = Jerk2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(ReverberationTime<T> left, Snap2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Snap3D = Jerk3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(ReverberationTime<T> left, Snap3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Snap4D = Jerk4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(ReverberationTime<T> left, Snap4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Frequency = Ratio, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(ReverberationTime<T> left, Frequency<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularSpeed = Angle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(ReverberationTime<T> left, AngularSpeed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularVelocity1D = SignedAngle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(ReverberationTime<T> left, AngularVelocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularVelocity3D = AngularDisplacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(ReverberationTime<T> left, AngularVelocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularAccelerationMagnitude = AngularSpeed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(ReverberationTime<T> left, AngularAccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularAcceleration1D = AngularVelocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(ReverberationTime<T> left, AngularAcceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularAcceleration3D = AngularVelocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(ReverberationTime<T> left, AngularAcceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularJerkMagnitude = AngularAccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(ReverberationTime<T> left, AngularJerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularJerk1D = AngularAcceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(ReverberationTime<T> left, AngularJerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * AngularJerk3D = AngularAcceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(ReverberationTime<T> left, AngularJerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * TorqueMagnitude = AngularMomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(ReverberationTime<T> left, TorqueMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Torque1D = AngularMomentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(ReverberationTime<T> left, Torque1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Torque3D = AngularMomentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(ReverberationTime<T> left, Torque3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * ForceMagnitude = MomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(ReverberationTime<T> left, ForceMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Force1D = Momentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(ReverberationTime<T> left, Force1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Force2D = Momentum2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(ReverberationTime<T> left, Force2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Force3D = Momentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(ReverberationTime<T> left, Force3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Force4D = Momentum4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(ReverberationTime<T> left, Force4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * Power = Energy, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(ReverberationTime<T> left, Power<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * VolumetricFlowRate = Volume, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(ReverberationTime<T> left, VolumetricFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * MassFlowRate = Mass, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(ReverberationTime<T> left, MassFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * CatalyticActivity = AmountOfSubstance, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(ReverberationTime<T> left, CatalyticActivity<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * ReactionRate = Concentration, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(ReverberationTime<T> left, ReactionRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>ReverberationTime * VoltageMagnitude = MagneticFlux, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(ReverberationTime<T> left, VoltageMagnitude<T> right) => (Duration<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs
index 0243ff1a..62533d00 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReynoldsNumber.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ReynoldsNumber values, returning the absolute difference as a non-negative ReynoldsNumber.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ReynoldsNumber<T> operator -(ReynoldsNumber<T> left, ReynoldsNumber<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ReynoldsNumber * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(ReynoldsNumber<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>ReynoldsNumber * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(ReynoldsNumber<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>ReynoldsNumber / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(ReynoldsNumber<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>ReynoldsNumber / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(ReynoldsNumber<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>ReynoldsNumber / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(ReynoldsNumber<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>ReynoldsNumber / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(ReynoldsNumber<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs
index 08911f0e..d2d5134c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Rotation.g.cs
@@ -149,5 +149,9 @@ namespace ktsu.Semantics.Quantities;
 
 	/// <summary>Creates a Rotation from a SignedAngle value.</summary>
 	public static Rotation<T> From(SignedAngle<T> value) => Create(value.Value);
+
+	/// <summary>Rotation / Duration = AngularVelocity1D, through <see cref="SignedAngle{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator /(Rotation<T> left, Duration<T> right) => (SignedAngle<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs
index 579d505e..a5142e08 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SamplingRate.g.cs
@@ -134,5 +134,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SamplingRate values, returning the absolute difference as a non-negative SamplingRate.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SamplingRate<T> operator -(SamplingRate<T> left, SamplingRate<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SamplingRate * Duration = Ratio, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(SamplingRate<T> left, Duration<T> right) => (Frequency<T>)left * right;
+
+	/// <summary>SamplingRate * Length = Speed, through <see cref="Frequency{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(SamplingRate<T> left, Length<T> right) => (Frequency<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs
index 633f6986..969b7c6c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ShearModulus.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ShearModulus values, returning the absolute difference as a non-negative ShearModulus.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ShearModulus<T> operator -(ShearModulus<T> left, ShearModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ShearModulus * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(ShearModulus<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>ShearModulus * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(ShearModulus<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>ShearModulus * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(ShearModulus<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs
index e822d6bd..b9b989e2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundAbsorption.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SoundAbsorption values, returning the absolute difference as a non-negative SoundAbsorption.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SoundAbsorption<T> operator -(SoundAbsorption<T> left, SoundAbsorption<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SoundAbsorption * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(SoundAbsorption<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>SoundAbsorption * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(SoundAbsorption<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>SoundAbsorption / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(SoundAbsorption<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SoundAbsorption / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(SoundAbsorption<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SoundAbsorption / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(SoundAbsorption<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SoundAbsorption / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(SoundAbsorption<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs
index 75bf0101..7e52033c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundIntensity.g.cs
@@ -118,5 +118,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SoundIntensity values, returning the absolute difference as a non-negative SoundIntensity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SoundIntensity<T> operator -(SoundIntensity<T> left, SoundIntensity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SoundIntensity * Area = Power, through <see cref="Irradiance{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(SoundIntensity<T> left, Area<T> right) => (Irradiance<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs
index 812140aa..be4ef4a8 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPower.g.cs
@@ -142,5 +142,41 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SoundPower values, returning the absolute difference as a non-negative SoundPower.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SoundPower<T> operator -(SoundPower<T> left, SoundPower<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SoundPower / VoltageMagnitude = CurrentMagnitude, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(SoundPower<T> left, VoltageMagnitude<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower / CurrentMagnitude = VoltageMagnitude, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator /(SoundPower<T> left, CurrentMagnitude<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower / Speed = ForceMagnitude, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(SoundPower<T> left, Speed<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower / ForceMagnitude = Speed, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(SoundPower<T> left, ForceMagnitude<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower * Duration = Energy, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(SoundPower<T> left, Duration<T> right) => (Power<T>)left * right;
+
+	/// <summary>SoundPower / Area = Irradiance, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Irradiance<T> operator /(SoundPower<T> left, Area<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower / Irradiance = Area, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator /(SoundPower<T> left, Irradiance<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower / Volume = ElectricPowerDensity, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricPowerDensity<T> operator /(SoundPower<T> left, Volume<T> right) => (Power<T>)left / right;
+
+	/// <summary>SoundPower / ElectricPowerDensity = Volume, through <see cref="Power{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(SoundPower<T> left, ElectricPowerDensity<T> right) => (Power<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs
index 0a492731..bd40fe80 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundPressure.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SoundPressure values, returning the absolute difference as a non-negative SoundPressure.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SoundPressure<T> operator -(SoundPressure<T> left, SoundPressure<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SoundPressure * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(SoundPressure<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>SoundPressure * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(SoundPressure<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>SoundPressure * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(SoundPressure<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs
index d8ec17c3..9d21ef18 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundSpeed.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SoundSpeed values, returning the absolute difference as a non-negative SoundSpeed.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SoundSpeed<T> operator -(SoundSpeed<T> left, SoundSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SoundSpeed * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(SoundSpeed<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>SoundSpeed * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(SoundSpeed<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>SoundSpeed / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(SoundSpeed<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>SoundSpeed / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(SoundSpeed<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>SoundSpeed / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(SoundSpeed<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>SoundSpeed / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(SoundSpeed<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>SoundSpeed * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(SoundSpeed<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs
index 935cb853..4d81e650 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SoundTransmissionClass.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SoundTransmissionClass values, returning the absolute difference as a non-negative SoundTransmissionClass.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SoundTransmissionClass<T> operator -(SoundTransmissionClass<T> left, SoundTransmissionClass<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SoundTransmissionClass * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(SoundTransmissionClass<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>SoundTransmissionClass * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(SoundTransmissionClass<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>SoundTransmissionClass / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(SoundTransmissionClass<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SoundTransmissionClass / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(SoundTransmissionClass<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SoundTransmissionClass / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(SoundTransmissionClass<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SoundTransmissionClass / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(SoundTransmissionClass<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs
index 1a873b3a..ae38700b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEntropy.g.cs
@@ -118,5 +118,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SpecificEntropy values, returning the absolute difference as a non-negative SpecificEntropy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SpecificEntropy<T> operator -(SpecificEntropy<T> left, SpecificEntropy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SpecificEntropy * Mass = Entropy, through <see cref="SpecificHeat{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator *(SpecificEntropy<T> left, Mass<T> right) => (SpecificHeat<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs
index 103a5410..ade4c3eb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificGravity.g.cs
@@ -190,5 +190,29 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SpecificGravity values, returning the absolute difference as a non-negative SpecificGravity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SpecificGravity<T> operator -(SpecificGravity<T> left, SpecificGravity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SpecificGravity * Ratio = Ratio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(SpecificGravity<T> left, Ratio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>SpecificGravity * SignedRatio = SignedRatio, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedRatio<T> operator *(SpecificGravity<T> left, SignedRatio<T> right) => (Ratio<T>)left * right;
+
+	/// <summary>SpecificGravity / Duration = Frequency, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(SpecificGravity<T> left, Duration<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SpecificGravity / Frequency = Duration, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(SpecificGravity<T> left, Frequency<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SpecificGravity / Temperature = ThermalExpansionCoefficient, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ThermalExpansionCoefficient<T> operator /(SpecificGravity<T> left, Temperature<T> right) => (Ratio<T>)left / right;
+
+	/// <summary>SpecificGravity / ThermalExpansionCoefficient = Temperature, through <see cref="Ratio{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(SpecificGravity<T> left, ThermalExpansionCoefficient<T> right) => (Ratio<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificKineticEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificKineticEnergy.g.cs
index 9ef05310..93231866 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificKineticEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificKineticEnergy.g.cs
@@ -118,5 +118,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SpecificKineticEnergy values, returning the absolute difference as a non-negative SpecificKineticEnergy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SpecificKineticEnergy<T> operator -(SpecificKineticEnergy<T> left, SpecificKineticEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SpecificKineticEnergy * Length = GravitationalParameter, through <see cref="SpecificEnergyMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(SpecificKineticEnergy<T> left, Length<T> right) => (SpecificEnergyMagnitude<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/StandardGravitationalParameter.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/StandardGravitationalParameter.g.cs
index 74c69c8e..cd66f7bd 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/StandardGravitationalParameter.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/StandardGravitationalParameter.g.cs
@@ -126,5 +126,13 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two StandardGravitationalParameter values, returning the absolute difference as a non-negative StandardGravitationalParameter.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static StandardGravitationalParameter<T> operator -(StandardGravitationalParameter<T> left, StandardGravitationalParameter<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>StandardGravitationalParameter / Area = AccelerationMagnitude, through <see cref="GravitationalParameter{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(StandardGravitationalParameter<T> left, Area<T> right) => (GravitationalParameter<T>)left / right;
+
+	/// <summary>StandardGravitationalParameter / Length = SpecificEnergyMagnitude, through <see cref="GravitationalParameter{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SpecificEnergyMagnitude<T> operator /(StandardGravitationalParameter<T> left, Length<T> right) => (GravitationalParameter<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs
index f73f0f70..8e33348d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Stress.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Stress values, returning the absolute difference as a non-negative Stress.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Stress<T> operator -(Stress<T> left, Stress<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Stress * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Stress<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>Stress * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Stress<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>Stress * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Stress<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs
index 3e81fd41..b6fd3196 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceArea.g.cs
@@ -174,5 +174,41 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two SurfaceArea values, returning the absolute difference as a non-negative SurfaceArea.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SurfaceArea<T> operator -(SurfaceArea<T> left, SurfaceArea<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>SurfaceArea / Length = Length, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(SurfaceArea<T> left, Length<T> right) => (Area<T>)left / right;
+
+	/// <summary>SurfaceArea * Length = Volume, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(SurfaceArea<T> left, Length<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * Pressure = ForceMagnitude, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(SurfaceArea<T> left, Pressure<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * ElectricFieldMagnitude = ElectricFlux, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFlux<T> operator *(SurfaceArea<T> left, ElectricFieldMagnitude<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * Illuminance = LuminousFlux, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousFlux<T> operator *(SurfaceArea<T> left, Illuminance<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * MagneticFluxDensityMagnitude = MagneticFlux, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(SurfaceArea<T> left, MagneticFluxDensityMagnitude<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * Irradiance = Power, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(SurfaceArea<T> left, Irradiance<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * Luminance = LuminousIntensity, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static LuminousIntensity<T> operator *(SurfaceArea<T> left, Luminance<T> right) => (Area<T>)left * right;
+
+	/// <summary>SurfaceArea * AccelerationMagnitude = GravitationalParameter, through <see cref="Area{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(SurfaceArea<T> left, AccelerationMagnitude<T> right) => (Area<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs
index e9eec34a..9870eb42 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Tension.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Tension values, returning the absolute difference as a non-negative Tension.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Tension<T> operator -(Tension<T> left, Tension<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Tension / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Tension<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Tension / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Tension<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Tension * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Tension<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Tension * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Tension<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Tension * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Tension<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Tension / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Tension<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Tension / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(Tension<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Tension / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Tension<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs
index c525e3a2..bcbfaa50 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalDiffusivity.g.cs
@@ -126,5 +126,9 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ThermalDiffusivity values, returning the absolute difference as a non-negative ThermalDiffusivity.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ThermalDiffusivity<T> operator -(ThermalDiffusivity<T> left, ThermalDiffusivity<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ThermalDiffusivity * Density = DynamicViscosity, through <see cref="KinematicViscosity{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static DynamicViscosity<T> operator *(ThermalDiffusivity<T> left, Density<T> right) => (KinematicViscosity<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs
index 5c511ff3..67c6392e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalEnergy.g.cs
@@ -182,5 +182,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two ThermalEnergy values, returning the absolute difference as a non-negative ThermalEnergy.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ThermalEnergy<T> operator -(ThermalEnergy<T> left, ThermalEnergy<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>ThermalEnergy / Length = ForceMagnitude, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(ThermalEnergy<T> left, Length<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / ForceMagnitude = Length, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(ThermalEnergy<T> left, ForceMagnitude<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / Volume = Pressure, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(ThermalEnergy<T> left, Volume<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / Pressure = Volume, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(ThermalEnergy<T> left, Pressure<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / Duration = Power, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator /(ThermalEnergy<T> left, Duration<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / Power = Duration, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(ThermalEnergy<T> left, Power<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / Temperature = Entropy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator /(ThermalEnergy<T> left, Temperature<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / Entropy = Temperature, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(ThermalEnergy<T> left, Entropy<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / AmountOfSubstance = MolarEnergy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator /(ThermalEnergy<T> left, AmountOfSubstance<T> right) => (Energy<T>)left / right;
+
+	/// <summary>ThermalEnergy / MolarEnergy = AmountOfSubstance, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(ThermalEnergy<T> left, MolarEnergy<T> right) => (Energy<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs
index 6eae6e83..aec084df 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thickness.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Thickness values, returning the absolute difference as a non-negative Thickness.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Thickness<T> operator -(Thickness<T> left, Thickness<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Thickness * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Thickness<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Thickness<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Thickness<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Thickness / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Thickness<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Thickness * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Thickness<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Thickness<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Thickness<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Thickness<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Thickness<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Thickness * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Thickness<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs
index faaea691..3f7b1c2e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Thrust.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Thrust values, returning the absolute difference as a non-negative Thrust.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Thrust<T> operator -(Thrust<T> left, Thrust<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Thrust / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Thrust<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Thrust / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Thrust<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Thrust * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Thrust<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Thrust * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Thrust<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Thrust * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Thrust<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Thrust / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Thrust<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Thrust / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(Thrust<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Thrust / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Thrust<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs
index eb121302..f7efeec0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThrustVector.g.cs
@@ -146,6 +146,9 @@ public ThrustVector<T> Normalize()
 
 	/// <summary>Negates a vector.</summary>
 	public static ThrustVector<T> operator -(ThrustVector<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
+	/// <summary>ThrustVector * Duration = Momentum3D, through <see cref="Force3D{T}"/>.</summary>
+	public static Momentum3D<T> operator *(ThrustVector<T> left, Duration<T> right) => (Force3D<T>)left * right;
+
 	/// <summary>Implicit conversion to Force3D.</summary>
 	public static implicit operator Force3D<T>(ThrustVector<T> value) => new() { X = value.X, Y = value.Y, Z = value.Z };
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs
index 25247401..ab34248e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TimeConstant.g.cs
@@ -182,5 +182,189 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two TimeConstant values, returning the absolute difference as a non-negative TimeConstant.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static TimeConstant<T> operator -(TimeConstant<T> left, TimeConstant<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>TimeConstant * CurrentMagnitude = ChargeMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(TimeConstant<T> left, CurrentMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Current1D = Charge, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Charge<T> operator *(TimeConstant<T> left, Current1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Speed = Length, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(TimeConstant<T> left, Speed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Velocity1D = Displacement1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement1D<T> operator *(TimeConstant<T> left, Velocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Velocity2D = Displacement2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement2D<T> operator *(TimeConstant<T> left, Velocity2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Velocity3D = Displacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement3D<T> operator *(TimeConstant<T> left, Velocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Velocity4D = Displacement4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Displacement4D<T> operator *(TimeConstant<T> left, Velocity4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AccelerationMagnitude = Speed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(TimeConstant<T> left, AccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Acceleration1D = Velocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity1D<T> operator *(TimeConstant<T> left, Acceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Acceleration2D = Velocity2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity2D<T> operator *(TimeConstant<T> left, Acceleration2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Acceleration3D = Velocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity3D<T> operator *(TimeConstant<T> left, Acceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Acceleration4D = Velocity4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Velocity4D<T> operator *(TimeConstant<T> left, Acceleration4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * JerkMagnitude = AccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator *(TimeConstant<T> left, JerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Jerk1D = Acceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration1D<T> operator *(TimeConstant<T> left, Jerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Jerk2D = Acceleration2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration2D<T> operator *(TimeConstant<T> left, Jerk2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Jerk3D = Acceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration3D<T> operator *(TimeConstant<T> left, Jerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Jerk4D = Acceleration4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Acceleration4D<T> operator *(TimeConstant<T> left, Jerk4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * SnapMagnitude = JerkMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static JerkMagnitude<T> operator *(TimeConstant<T> left, SnapMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Snap1D = Jerk1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk1D<T> operator *(TimeConstant<T> left, Snap1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Snap2D = Jerk2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk2D<T> operator *(TimeConstant<T> left, Snap2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Snap3D = Jerk3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk3D<T> operator *(TimeConstant<T> left, Snap3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Snap4D = Jerk4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Jerk4D<T> operator *(TimeConstant<T> left, Snap4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Frequency = Ratio, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Ratio<T> operator *(TimeConstant<T> left, Frequency<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularSpeed = Angle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Angle<T> operator *(TimeConstant<T> left, AngularSpeed<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularVelocity1D = SignedAngle, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SignedAngle<T> operator *(TimeConstant<T> left, AngularVelocity1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularVelocity3D = AngularDisplacement3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularDisplacement3D<T> operator *(TimeConstant<T> left, AngularVelocity3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularAccelerationMagnitude = AngularSpeed, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularSpeed<T> operator *(TimeConstant<T> left, AngularAccelerationMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularAcceleration1D = AngularVelocity1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity1D<T> operator *(TimeConstant<T> left, AngularAcceleration1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularAcceleration3D = AngularVelocity3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularVelocity3D<T> operator *(TimeConstant<T> left, AngularAcceleration3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularJerkMagnitude = AngularAccelerationMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAccelerationMagnitude<T> operator *(TimeConstant<T> left, AngularJerkMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularJerk1D = AngularAcceleration1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration1D<T> operator *(TimeConstant<T> left, AngularJerk1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * AngularJerk3D = AngularAcceleration3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularAcceleration3D<T> operator *(TimeConstant<T> left, AngularJerk3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * TorqueMagnitude = AngularMomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentumMagnitude<T> operator *(TimeConstant<T> left, TorqueMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Torque1D = AngularMomentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum1D<T> operator *(TimeConstant<T> left, Torque1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Torque3D = AngularMomentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AngularMomentum3D<T> operator *(TimeConstant<T> left, Torque3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * ForceMagnitude = MomentumMagnitude, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(TimeConstant<T> left, ForceMagnitude<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Force1D = Momentum1D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum1D<T> operator *(TimeConstant<T> left, Force1D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Force2D = Momentum2D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum2D<T> operator *(TimeConstant<T> left, Force2D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Force3D = Momentum3D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum3D<T> operator *(TimeConstant<T> left, Force3D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Force4D = Momentum4D, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Momentum4D<T> operator *(TimeConstant<T> left, Force4D<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * Power = Energy, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(TimeConstant<T> left, Power<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * VolumetricFlowRate = Volume, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(TimeConstant<T> left, VolumetricFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * MassFlowRate = Mass, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator *(TimeConstant<T> left, MassFlowRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * CatalyticActivity = AmountOfSubstance, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator *(TimeConstant<T> left, CatalyticActivity<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * ReactionRate = Concentration, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Concentration<T> operator *(TimeConstant<T> left, ReactionRate<T> right) => (Duration<T>)left * right;
+
+	/// <summary>TimeConstant * VoltageMagnitude = MagneticFlux, through <see cref="Duration{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(TimeConstant<T> left, VoltageMagnitude<T> right) => (Duration<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs
index a6bd9f74..38fbf13b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Translation3D.g.cs
@@ -202,6 +202,9 @@ public Translation3D<T> Normalize()
 
 	/// <summary>Negates a vector.</summary>
 	public static Translation3D<T> operator -(Translation3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
+	/// <summary>Translation3D / Duration = Velocity3D, through <see cref="Displacement3D{T}"/>.</summary>
+	public static Velocity3D<T> operator /(Translation3D<T> left, Duration<T> right) => (Displacement3D<T>)left / right;
+
 	/// <summary>Implicit conversion to Displacement3D.</summary>
 	public static implicit operator Displacement3D<T>(Translation3D<T> value) => new() { X = value.X, Y = value.Y, Z = value.Z };
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs
index 12a202db..8b824c18 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VoltageDrop.g.cs
@@ -126,5 +126,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two VoltageDrop values, returning the absolute difference as a non-negative VoltageDrop.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static VoltageDrop<T> operator -(VoltageDrop<T> left, VoltageDrop<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>VoltageDrop / Resistance = CurrentMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator /(VoltageDrop<T> left, Resistance<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>VoltageDrop / CurrentMagnitude = Resistance, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Resistance<T> operator /(VoltageDrop<T> left, CurrentMagnitude<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>VoltageDrop * CurrentMagnitude = Power, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(VoltageDrop<T> left, CurrentMagnitude<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>VoltageDrop / Length = ElectricFieldMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ElectricFieldMagnitude<T> operator /(VoltageDrop<T> left, Length<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>VoltageDrop / ElectricFieldMagnitude = Length, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(VoltageDrop<T> left, ElectricFieldMagnitude<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>VoltageDrop * Capacitance = ChargeMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ChargeMagnitude<T> operator *(VoltageDrop<T> left, Capacitance<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>VoltageDrop * Conductance = CurrentMagnitude, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static CurrentMagnitude<T> operator *(VoltageDrop<T> left, Conductance<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>VoltageDrop * Duration = MagneticFlux, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MagneticFlux<T> operator *(VoltageDrop<T> left, Duration<T> right) => (VoltageMagnitude<T>)left * right;
+
+	/// <summary>VoltageDrop / Pressure = Sensitivity, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Sensitivity<T> operator /(VoltageDrop<T> left, Pressure<T> right) => (VoltageMagnitude<T>)left / right;
+
+	/// <summary>VoltageDrop / Sensitivity = Pressure, through <see cref="VoltageMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(VoltageDrop<T> left, Sensitivity<T> right) => (VoltageMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
index d2b90995..b4122a1d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Wavelength values, returning the absolute difference as a positive Wavelength. Throws <see cref="System.ArgumentException"/> when the two are equal, since a Wavelength cannot be zero; widen to <see cref="Length{T}"/> first for a difference that may be.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Wavelength<T> operator -(Wavelength<T> left, Wavelength<T> right) => Create(Vector0Guards.EnsurePositive(T.Abs(left.Quantity - right.Quantity), nameof(right)));
+
+	/// <summary>Wavelength * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Wavelength<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Wavelength<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Wavelength<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Wavelength / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Wavelength<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Wavelength * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Wavelength<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Wavelength<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Wavelength<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Wavelength<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Wavelength<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Wavelength * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Wavelength<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs
index 315d9e58..d9dae496 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Weight.g.cs
@@ -142,5 +142,37 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Weight values, returning the absolute difference as a non-negative Weight.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Weight<T> operator -(Weight<T> left, Weight<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Weight / AccelerationMagnitude = Mass, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Mass<T> operator /(Weight<T> left, AccelerationMagnitude<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Weight / Mass = AccelerationMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(Weight<T> left, Mass<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Weight * Length = Energy, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Weight<T> left, Length<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Weight * Duration = MomentumMagnitude, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(Weight<T> left, Duration<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Weight * Speed = Power, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(Weight<T> left, Speed<T> right) => (ForceMagnitude<T>)left * right;
+
+	/// <summary>Weight / Area = Pressure, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Weight<T> left, Area<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Weight / Length = SurfaceTension, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static SurfaceTension<T> operator /(Weight<T> left, Length<T> right) => (ForceMagnitude<T>)left / right;
+
+	/// <summary>Weight / SurfaceTension = Length, through <see cref="ForceMagnitude{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Weight<T> left, SurfaceTension<T> right) => (ForceMagnitude<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs
index 400971b7..e9c6dd94 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WeightVector.g.cs
@@ -146,6 +146,9 @@ public WeightVector<T> Normalize()
 
 	/// <summary>Negates a vector.</summary>
 	public static WeightVector<T> operator -(WeightVector<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
+	/// <summary>WeightVector * Duration = Momentum3D, through <see cref="Force3D{T}"/>.</summary>
+	public static Momentum3D<T> operator *(WeightVector<T> left, Duration<T> right) => (Force3D<T>)left * right;
+
 	/// <summary>Implicit conversion to Force3D.</summary>
 	public static implicit operator Force3D<T>(WeightVector<T> value) => new() { X = value.X, Y = value.Y, Z = value.Z };
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs
index a74b2bef..6891e40a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Width.g.cs
@@ -206,5 +206,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Width values, returning the absolute difference as a non-negative Width.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Width<T> operator -(Width<T> left, Width<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Width * Length = Area, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Area<T> operator *(Width<T> left, Length<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width * Area = Volume, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator *(Width<T> left, Area<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width / Duration = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator /(Width<T> left, Duration<T> right) => (Length<T>)left / right;
+
+	/// <summary>Width / Speed = Duration, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Width<T> left, Speed<T> right) => (Length<T>)left / right;
+
+	/// <summary>Width * Frequency = Speed, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Speed<T> operator *(Width<T> left, Frequency<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width * ForceMagnitude = Energy, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(Width<T> left, ForceMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width * ElectricFieldMagnitude = VoltageMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(Width<T> left, ElectricFieldMagnitude<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width * ElectricField1D = Voltage, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Voltage<T> operator *(Width<T> left, ElectricField1D<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width * SurfaceTension = ForceMagnitude, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(Width<T> left, SurfaceTension<T> right) => (Length<T>)left * right;
+
+	/// <summary>Width * SpecificEnergyMagnitude = GravitationalParameter, through <see cref="Length{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static GravitationalParameter<T> operator *(Width<T> left, SpecificEnergyMagnitude<T> right) => (Length<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs
index 2d8c9fe6..7cc1cc4b 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindSpeed.g.cs
@@ -158,5 +158,33 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two WindSpeed values, returning the absolute difference as a non-negative WindSpeed.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static WindSpeed<T> operator -(WindSpeed<T> left, WindSpeed<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>WindSpeed * Mass = MomentumMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MomentumMagnitude<T> operator *(WindSpeed<T> left, Mass<T> right) => (Speed<T>)left * right;
+
+	/// <summary>WindSpeed * Duration = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator *(WindSpeed<T> left, Duration<T> right) => (Speed<T>)left * right;
+
+	/// <summary>WindSpeed / Duration = AccelerationMagnitude, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AccelerationMagnitude<T> operator /(WindSpeed<T> left, Duration<T> right) => (Speed<T>)left / right;
+
+	/// <summary>WindSpeed / AccelerationMagnitude = Duration, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(WindSpeed<T> left, AccelerationMagnitude<T> right) => (Speed<T>)left / right;
+
+	/// <summary>WindSpeed / Length = Frequency, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Frequency<T> operator /(WindSpeed<T> left, Length<T> right) => (Speed<T>)left / right;
+
+	/// <summary>WindSpeed / Frequency = Length, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(WindSpeed<T> left, Frequency<T> right) => (Speed<T>)left / right;
+
+	/// <summary>WindSpeed * ForceMagnitude = Power, through <see cref="Speed{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator *(WindSpeed<T> left, ForceMagnitude<T> right) => (Speed<T>)left * right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs
index 47ad968b..cf9ab66d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/WindVelocity3D.g.cs
@@ -160,6 +160,12 @@ public WindVelocity3D<T> Normalize()
 
 	/// <summary>Negates a vector.</summary>
 	public static WindVelocity3D<T> operator -(WindVelocity3D<T> vector) => new() { X = -vector.X, Y = -vector.Y, Z = -vector.Z };
+	/// <summary>WindVelocity3D * Duration = Displacement3D, through <see cref="Velocity3D{T}"/>.</summary>
+	public static Displacement3D<T> operator *(WindVelocity3D<T> left, Duration<T> right) => (Velocity3D<T>)left * right;
+
+	/// <summary>WindVelocity3D / Duration = Acceleration3D, through <see cref="Velocity3D{T}"/>.</summary>
+	public static Acceleration3D<T> operator /(WindVelocity3D<T> left, Duration<T> right) => (Velocity3D<T>)left / right;
+
 	/// <summary>Implicit conversion to Velocity3D.</summary>
 	public static implicit operator Velocity3D<T>(WindVelocity3D<T> value) => new() { X = value.X, Y = value.Y, Z = value.Z };
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs
index 7852c592..335704a3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Work.g.cs
@@ -182,5 +182,45 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two Work values, returning the absolute difference as a non-negative Work.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Work<T> operator -(Work<T> left, Work<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>Work / Length = ForceMagnitude, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator /(Work<T> left, Length<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / ForceMagnitude = Length, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Length<T> operator /(Work<T> left, ForceMagnitude<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / Volume = Pressure, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Pressure<T> operator /(Work<T> left, Volume<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / Pressure = Volume, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Volume<T> operator /(Work<T> left, Pressure<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / Duration = Power, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Power<T> operator /(Work<T> left, Duration<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / Power = Duration, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Duration<T> operator /(Work<T> left, Power<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / Temperature = Entropy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Entropy<T> operator /(Work<T> left, Temperature<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / Entropy = Temperature, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Temperature<T> operator /(Work<T> left, Entropy<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / AmountOfSubstance = MolarEnergy, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static MolarEnergy<T> operator /(Work<T> left, AmountOfSubstance<T> right) => (Energy<T>)left / right;
+
+	/// <summary>Work / MolarEnergy = AmountOfSubstance, through <see cref="Energy{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static AmountOfSubstance<T> operator /(Work<T> left, MolarEnergy<T> right) => (Energy<T>)left / right;
 }
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs
index 98fcf3df..3bea4c8a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/YoungsModulus.g.cs
@@ -158,5 +158,17 @@ namespace ktsu.Semantics.Quantities;
 	/// <summary>Subtracts two YoungsModulus values, returning the absolute difference as a non-negative YoungsModulus.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static YoungsModulus<T> operator -(YoungsModulus<T> left, YoungsModulus<T> right) => Create(T.Abs(left.Quantity - right.Quantity));
+
+	/// <summary>YoungsModulus * Area = ForceMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static ForceMagnitude<T> operator *(YoungsModulus<T> left, Area<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>YoungsModulus * Volume = Energy, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static Energy<T> operator *(YoungsModulus<T> left, Volume<T> right) => (Pressure<T>)left * right;
+
+	/// <summary>YoungsModulus * Sensitivity = VoltageMagnitude, through <see cref="Pressure{T}"/>.</summary>
+	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
+	public static VoltageMagnitude<T> operator *(YoungsModulus<T> left, Sensitivity<T> right) => (Pressure<T>)left * right;
 }
 
diff --git a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
index 07792cd5..22478f71 100644
--- a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
@@ -1381,6 +1381,26 @@ private void EmitOverloadType(
 			});
 		}
 
+		// Relationship operators reach an overload by forwarding to its base (#456). C# looks for an operator only
+		// on the two operand types and never widens the left operand to find one, so without these
+		// Distance / Duration did not compile while Duration * Distance did.
+		foreach (OperatorInfo op in ForwardedOperators(baseTypeName, emission))
+		{
+			cls.Members.Add(new MethodTemplate()
+			{
+				Comments = {$"/// <summary>{typeName} {op.Op} {op.RightTypeName} = {op.ReturnTypeName}, through <see cref=\"{baseTypeName}{{T}}\"/>.</summary>"},
+				Attributes = {Emit.PhysicsOperatorSuppression},
+				Keywords = {Emit.Public, Emit.Static, $"{op.ReturnTypeName}<T>"},
+				Name = $"operator {op.Op}",
+				Parameters =
+				{
+					new ParameterTemplate { Type = fullType, Name = "left" },
+					new ParameterTemplate { Type = $"{op.RightTypeName}<T>", Name = Emit.RightParameter },
+				},
+				BodyFactory = (body) => body.Write($"=> ({baseFullType})left {op.Op} right;"),
+			});
+		}
+
 		// Relationship methods (e.g., Diameter.ToRadius(), Diameter.FromRadius()). The one
 		// thing an overload declares that the vocabulary does not carry: these are C#
 		// expressions written in the metadata and pasted through, so there is nothing in
@@ -1472,6 +1492,14 @@ private static void EmitVectorOverloadType(
 			WriteVectorMethods(cb, fullType, components, dims);
 			WriteVectorOperators(cb, fullType, components);
 
+			// Relationship operators, forwarded to the base as the scalar overloads do (#456).
+			foreach (OperatorInfo op in ForwardedOperators(baseTypeName, emission))
+			{
+				cb.WriteLine($"/// <summary>{typeName} {op.Op} {op.RightTypeName} = {op.ReturnTypeName}, through <see cref=\"{baseTypeName}{{T}}\"/>.</summary>");
+				cb.WriteLine($"public static {op.ReturnTypeName}<T> operator {op.Op}({fullType} left, {op.RightTypeName}<T> right) => ({baseFullType})left {op.Op} right;");
+				cb.NewLine();
+			}
+
 			// Implicit widening to base
 			string baseInit = string.Join(", ", components.Select(c => $"{c} = value.{c}"));
 			cb.WriteLine($"/// <summary>Implicit conversion to {baseTypeName}.</summary>");
@@ -1491,6 +1519,41 @@ private static void EmitVectorOverloadType(
 
 	#region Operator Emission Helpers
 
+	/// <summary>
+	/// The relationship operators a base type declares with itself on the left, which an overload of it forwards.
+	/// </summary>
+	/// <remarks>
+	/// Every relationship operator is declared on its left operand's type, so one with the base on the right is
+	/// already reachable from an overload, which widens to it there. Forwarding only the left-hand ones is also
+	/// what keeps a product of two overloads unambiguous: for <c>Width * Height</c> only <c>(Width, Length)</c>
+	/// applies, since <c>Width</c> does not convert to <c>Height</c>. The filter matches what
+	/// <see cref="EmitScalarOperators"/> and <see cref="EmitVectorCrossDimOperators"/> actually write.
+	/// </remarks>
+	private static IEnumerable<OperatorInfo> ForwardedOperators(string baseTypeName, Emission emission)
+	{
+		if (!emission.OperatorsByOwner.TryGetValue(baseTypeName, out List<OperatorInfo>? ops))
+		{
+			yield break;
+		}
+
+		HashSet<string> signatures = [];
+		foreach (OperatorInfo op in ops)
+		{
+			int leftForm = GetFormOrDefault(emission.TypeFormMap, op.LeftTypeName);
+			int rightForm = GetFormOrDefault(emission.TypeFormMap, op.RightTypeName);
+			int resultForm = GetFormOrDefault(emission.TypeFormMap, op.ReturnTypeName);
+
+			bool emitted = (leftForm <= 1 && rightForm <= 1)
+				|| (resultForm >= 2 && leftForm >= 2 && rightForm <= 1)
+				|| (resultForm >= 2 && leftForm <= 1 && rightForm >= 2 && op.Op == "*");
+
+			if (op.LeftTypeName == baseTypeName && emitted && signatures.Add($"{op.Op}:{op.RightTypeName}"))
+			{
+				yield return op;
+			}
+		}
+	}
+
 	private static void EmitScalarOperators(ClassTemplate cls, string ownerTypeName, Emission emission)
 	{
 		if (!emission.OperatorsByOwner.TryGetValue(ownerTypeName, out List<OperatorInfo>? ops))
diff --git a/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs b/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs
index a3024d35..5ff977f2 100644
--- a/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs
+++ b/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs
@@ -96,6 +96,21 @@ public void EveryCrossDimensionalMultiplicationHasBothOperandOrders()
 			}
 		}
 
+		// A semantic overload forwards its base's products with itself on the left (#456). The swapped order
+		// needs no operator of its own: the base's operator is declared on the other operand's type, and the
+		// overload widens to the base there.
+		Dictionary<string, string> baseOf = [];
+		foreach (Type type in types)
+		{
+			foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly))
+			{
+				if (m.Name == "op_Implicit" && m.GetParameters()[0].ParameterType.Name == type.Name && m.ReturnType.Namespace == type.Namespace)
+				{
+					baseOf[type.Name] = m.ReturnType.Name;
+				}
+			}
+		}
+
 		// For every cross-dimensional product (operands of distinct types), the swapped pair
 		// should also be present with the same return. Same-type products (T * T) are exempt
 		// because there is no swap — they're idempotent under reorder.
@@ -107,7 +122,8 @@ public void EveryCrossDimensionalMultiplicationHasBothOperandOrders()
 				continue;
 			}
 
-			if (!observed.Contains((right, left, result)))
+			bool reachedThroughBase = baseOf.TryGetValue(left, out string? leftBase) && observed.Contains((right, leftBase, result));
+			if (!observed.Contains((right, left, result)) && !reachedThroughBase)
 			{
 				missing.Add($"missing reverse pair: {right} * {left} -> {result} (forward {left} * {right} -> {result} exists)");
 			}
diff --git a/Semantics.Test/Quantities/OverloadRelationshipOperatorTests.cs b/Semantics.Test/Quantities/OverloadRelationshipOperatorTests.cs
new file mode 100644
index 00000000..f0a05ad0
--- /dev/null
+++ b/Semantics.Test/Quantities/OverloadRelationshipOperatorTests.cs
@@ -0,0 +1,68 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Test.Quantities;
+
+using ktsu.Semantics.Quantities;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Issue #456: a semantic overload on the left of a relationship operator reaches its base's operator.
+/// Each of these failed to compile with CS0019 before, so compiling is half of what is tested.
+/// </summary>
+[TestClass]
+public sealed class OverloadRelationshipOperatorTests
+{
+	private const double Tolerance = 1e-12;
+
+	[TestMethod]
+	public void DistanceOverDuration_IsASpeed()
+	{
+		Speed<double> speed = Distance<double>.FromMeter(100) / Duration<double>.FromSecond(10);
+		Assert.AreEqual(10.0, speed.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void WidthTimesWidth_IsAnArea()
+	{
+		Width<double> width = Width<double>.FromMeter(2);
+		Area<double> area = width * width;
+		Assert.AreEqual(4.0, area.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void WidthTimesHeight_IsAnArea()
+	{
+		Area<double> area = Width<double>.FromMeter(2) * Height<double>.FromMeter(3);
+		Assert.AreEqual(6.0, area.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void WeightTimesHeight_IsAnEnergy()
+	{
+		Energy<double> energy = Weight<double>.FromNewton(9.8) * Height<double>.FromMeter(10);
+		Assert.AreEqual(98.0, energy.Value, 1e-9);
+	}
+
+	[TestMethod]
+	public void OperandOrder_NoLongerDecidesWhetherItCompiles()
+	{
+		Width<double> width = Width<double>.FromMeter(2);
+		ForceMagnitude<double> force = ForceMagnitude<double>.FromNewton(3);
+
+		Energy<double> leftFirst = width * force;
+		Energy<double> rightFirst = force * width;
+
+		Assert.AreEqual(rightFirst.Value, leftFirst.Value, Tolerance);
+		Assert.AreEqual(6.0, leftFirst.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void WindVelocityTimesDuration_IsADisplacement()
+	{
+		Displacement3D<double> displacement = WindVelocity3D<double>.FromMeterPerSecond(1, 2, 3) * Duration<double>.FromSecond(2);
+
+		Assert.AreEqual(2.0, displacement.X, Tolerance);
+		Assert.AreEqual(4.0, displacement.Y, Tolerance);
+		Assert.AreEqual(6.0, displacement.Z, Tolerance);
+	}
+}
diff --git a/docs/migration-guide-2.0.md b/docs/migration-guide-2.0.md
index 7e2dfad2..0e67a7a1 100644
--- a/docs/migration-guide-2.0.md
+++ b/docs/migration-guide-2.0.md
@@ -96,8 +96,9 @@ Force1D<double> net = thrustSigned - brakeSigned;
 
 A `Weight<T>` is implicitly a `ForceMagnitude<T>`; converting back requires
 `Weight<T>.From(force)` or an explicit cast. Cross-dimensional operators are
-defined on the base types and apply to overloads through widening — Ohm's law
-works with an `Impedance` because it widens to `Resistance`.
+defined on the base types, and each overload carries forwarding copies of the
+ones with its base on the left, so Ohm's law works with an `Impedance` in either
+operand position. (From 4.0 until #456 an overload on the left did not compile.)
 
 ### Storage-unit fixes (silent value changes!)
 
diff --git a/docs/physics-generator.md b/docs/physics-generator.md
index 3a7ff4bd..baf47c4b 100644
--- a/docs/physics-generator.md
+++ b/docs/physics-generator.md
@@ -83,11 +83,12 @@ The C# itself is described with the template object model from `ktsu.CodeBlocker
 
 An overload (e.g. `Width`, `Height`, `Depth` on `Length`) emits:
 
-- A record extending the base type but with its own identity: `record Width<T> : Length<T>`.
+- A `readonly record struct` of its own, `Width<T>`, holding the same value its base would. Since 4.0 there is no inheritance between them.
 - Implicit operator widening to the base.
 - Explicit operator narrowing from the base.
 - A `From(base)` factory.
 - Per-relationship `To{Other}()` / `From{Other}()` methods if `relationships` is set.
+- A forwarding copy of every relationship operator its base declares with the base on the left, such as `Speed<T> operator /(Distance<T>, Duration<T>)`, written as a widening and a call to the base's operator (#456). C# looks for an operator only on the two operand types and never widens the left operand to find one, so without these `distance / duration` would not compile while `duration * distance` would. The base on the right needs no copy: that operator is declared on the other operand's type, and the overload widens to the base there. Results stay base types.
 
 Operator preservation (e.g. `Width + Width => Width` vs. `Width + Length => Length`) is generated, and follows the rule "narrowest-shared overload wins; otherwise widen to base".
 
diff --git a/docs/strategy-unified-vector-quantities.md b/docs/strategy-unified-vector-quantities.md
index ecada530..7f002897 100644
--- a/docs/strategy-unified-vector-quantities.md
+++ b/docs/strategy-unified-vector-quantities.md
@@ -355,7 +355,7 @@ dimension check can catch that, since a cross product and its negation have iden
 
 ### How Semantic Overloads Participate
 
-Semantic overloads participate in cross-dimensional operations through implicit widening to their base type. The resolution chain:
+Semantic overloads participate in cross-dimensional operations through forwarding operators and implicit widening to their base type. C# looks for an operator only on the two operand types, and never widens the left operand to find one, so each overload declares a copy of every relationship operator its base has with the base on the left (#456). The resolution chain:
 
 ```csharp
 // User writes:
@@ -364,10 +364,10 @@ Height h = Height.FromMeter(10.0);       // V0 overload of Length
 Energy e = w * h;                         // How does this work?
 
 // Resolution:
-// 1. Weight implicitly converts to ForceMagnitude (base)
+// 1. Weight declares operator *(Weight, Length), forwarded from ForceMagnitude * Length
 // 2. Height implicitly converts to Length (base)
-// 3. ForceMagnitude * Length = Energy (generated operator)
-// 4. Result: Energy
+// 3. The forward widens Weight to ForceMagnitude and calls ForceMagnitude * Length = Energy
+// 4. Result: Energy (always the base type, never an overload)
 ```
 
 ```csharp

From 920e4e5fdbd516fbdd8355b2aed93598640df14c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 10:56:30 +0000
Subject: [PATCH 5/8] [patch] C++ prelude: a representation widens implicitly
 and narrows only explicitly (#451)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 .../GeneratedCppCompilesTests.cs              | 59 +++++++++++++++++++
 Semantics.Cpp/Prelude/quantity.hpp            | 15 ++++-
 2 files changed, 72 insertions(+), 2 deletions(-)

diff --git a/Semantics.Cpp.Test/GeneratedCppCompilesTests.cs b/Semantics.Cpp.Test/GeneratedCppCompilesTests.cs
index ec43c8e0..9e557627 100644
--- a/Semantics.Cpp.Test/GeneratedCppCompilesTests.cs
+++ b/Semantics.Cpp.Test/GeneratedCppCompilesTests.cs
@@ -179,6 +179,65 @@ public void AComponentwiseProductWithTheWrongDimensionDoesNotCompile()
 		Assert.AreNotEqual(0, exitCode, "a componentwise product whose exponents do not match the result type should be refused");
 	}
 
+	/// <summary>
+	/// A representation widens implicitly and narrows only when asked to. Issue #451.
+	/// </summary>
+	[TestMethod]
+	public void TheRepresentationWidensImplicitlyAndNarrowsExplicitly()
+	{
+		string directory = Emit();
+		File.WriteAllText(Path.Join(directory, "widening.cpp"), """
+			#include "quantities.hpp"
+			#include <type_traits>
+
+			using L = holo::Dimension<1>;
+			using F = holo::Quantity<L, float>;
+			using D = holo::Quantity<L, double>;
+
+			static_assert(std::is_convertible_v<F, D>);
+			static_assert(!std::is_convertible_v<D, F>);
+			static_assert(std::is_constructible_v<F, D>);
+			static_assert(!std::is_convertible_v<D, holo::Quantity<L, int>>);
+
+			// float + double was ambiguous while each converted to the other.
+			static_assert(std::is_same_v<decltype(F{ 1.0f } + D{ 2.0 }), D>);
+			static_assert((F{ 1.0f } + D{ 2.0 }).count() == 3.0);
+			static_assert(F{ D{ 0.5 } }.count() == 0.5f);
+
+			int main() { return 0; }
+			""");
+
+		(int exitCode, string output) = Compile(directory, "widening.cpp");
+
+		Assert.AreEqual(0, exitCode, $"widening should be implicit and mixed sums should resolve:\n{output}");
+	}
+
+	/// <summary>
+	/// Copy-initialising a narrower representation is refused rather than silently losing precision.
+	/// </summary>
+	[TestMethod]
+	public void AnImplicitNarrowingDoesNotCompile()
+	{
+		string directory = Emit();
+		File.WriteAllText(Path.Join(directory, "narrowing.cpp"), """
+			#include "quantities.hpp"
+
+			using L = holo::Dimension<1>;
+
+			holo::Quantity<L, float> narrowed()
+			{
+				holo::Quantity<L, float> f = holo::Quantity<L, double>{ 1e40 };
+				return f;
+			}
+
+			int main() { return 0; }
+			""");
+
+		(int exitCode, _) = Compile(directory, "narrowing.cpp");
+
+		Assert.AreNotEqual(0, exitCode, "double to float should need an explicit conversion");
+	}
+
 	private static string Emit()
 	{
 		string directory = Path.Join(Path.GetTempPath(), $"semantics-cpp-{Guid.NewGuid():N}");
diff --git a/Semantics.Cpp/Prelude/quantity.hpp b/Semantics.Cpp/Prelude/quantity.hpp
index 2fed4664..1ade622c 100644
--- a/Semantics.Cpp/Prelude/quantity.hpp
+++ b/Semantics.Cpp/Prelude/quantity.hpp
@@ -42,10 +42,21 @@ namespace @NAMESPACE@
 		{
 		}
 
-		// Widening the representation of the same dimension is safe and implicit.
+		// Widening the representation of the same dimension is safe and implicit. Widening is what
+		// list-initialisation accepts, which refuses double to float and anything to an integer, so
+		// the conversion runs one way only and float + double resolves to double rather than being
+		// ambiguous.
 		template <typename R2>
-			requires(!std::is_same_v<R2, Rep> && std::is_convertible_v<R2, Rep>)
+			requires(!std::is_same_v<R2, Rep> && requires(R2 r) { Rep{ r }; })
 		constexpr Quantity(Quantity<D, R2> other) noexcept
+			: value_(other.count())
+		{
+		}
+
+		// Narrowing is allowed, but only when it is written down.
+		template <typename R2>
+			requires(!std::is_same_v<R2, Rep> && std::is_convertible_v<R2, Rep> && !requires(R2 r) { Rep{ r }; })
+		explicit constexpr Quantity(Quantity<D, R2> other) noexcept
 			: value_(static_cast<Rep>(other.count()))
 		{
 		}

From 3c284f292179384f8b4bc3af5e736e716a775edb Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 10:59:52 +0000
Subject: [PATCH 6/8] [patch] Strings: TryCreate rejects without exceptions;
 validation attributes and the WeakString setter cached per type (#443, #444)

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 Semantics.Strings/SemanticString.cs           | 70 ++++++-------------
 .../SemanticStringValidationAttributes.cs     |  3 +-
 .../Strategies/ValidateAllStrategy.cs         | 18 ++++-
 .../Strategies/ValidateAnyStrategy.cs         | 18 ++++-
 .../Strategies/ValidationStrategyFactory.cs   |  4 +-
 .../Validation/ValidationAttributeCache.cs    | 41 +++++++++++
 .../SemanticStringCreationCostTests.cs        | 69 ++++++++++++++++++
 7 files changed, 164 insertions(+), 59 deletions(-)
 create mode 100644 Semantics.Strings/Validation/ValidationAttributeCache.cs
 create mode 100644 Semantics.Test/SemanticStringCreationCostTests.cs

diff --git a/Semantics.Strings/SemanticString.cs b/Semantics.Strings/SemanticString.cs
index 685608e0..4f319c2f 100644
--- a/Semantics.Strings/SemanticString.cs
+++ b/Semantics.Strings/SemanticString.cs
@@ -7,7 +7,6 @@ namespace ktsu.Semantics.Strings;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
-using System.Reflection;
 using System.Text;
 
 /// <summary>
@@ -533,7 +532,7 @@ public static TDest Create<TDest>(string? value)
 		where TDest : SemanticString<TDest>
 	{
 		TDest newInstance = FromStringInternal<TDest>(value: value);
-		return PerformValidation(value: newInstance);
+		return newInstance.IsValid() ? newInstance : throw new ArgumentException(message: ValidationFailureMessage(newInstance));
 	}
 
 	/// <summary>
@@ -629,28 +628,21 @@ private static TDest FromStringInternal<TDest>(string? value)
 	{
 		Ensure.NotNull(value);
 
-		Type typeOfTDest = typeof(TDest);
-		TDest newInstance = (TDest)Ensure.NotNull(Activator.CreateInstance(type: typeOfTDest));
-		PropertyInfo weakStringProperty = Ensure.NotNull(typeOfTDest.GetProperty(name: nameof(WeakString)));
-		weakStringProperty.SetValue(obj: newInstance, value: newInstance.MakeCanonical(value));
+		TDest newInstance = Ensure.NotNull(Activator.CreateInstance<TDest>());
+		WeakStringSetter<TDest>.Set(newInstance, newInstance.MakeCanonical(value));
 		return newInstance;
 	}
 
 	/// <summary>
-	/// Validates a semantic string instance and throws an exception if validation fails.
+	/// The <see cref="WeakString"/> init accessor as a delegate, looked up once per type rather than per value (#444).
 	/// </summary>
-	/// <typeparam name="TDest">The semantic string type being validated.</typeparam>
-	/// <param name="value">The semantic string instance to validate.</param>
-	/// <returns>The validated semantic string instance.</returns>
-	/// <exception cref="ArgumentException">The semantic string instance is null or fails validation.</exception>
-	private static TDest PerformValidation<TDest>(TDest? value)
+	/// <typeparam name="TDest">The semantic string type to set the value of.</typeparam>
+	private static class WeakStringSetter<TDest>
 		where TDest : SemanticString<TDest>
 	{
-		if (value == null || !value.IsValid())
-		{
-			throw new ArgumentException(message: ValidationFailureMessage(value));
-		}
-		return value;
+		internal static readonly Action<TDest, string> Set = (Action<TDest, string>)Delegate.CreateDelegate(
+			typeof(Action<TDest, string>),
+			Ensure.NotNull(typeof(TDest).GetProperty(name: nameof(WeakString))?.GetSetMethod()));
 	}
 
 	/// <summary>
@@ -796,14 +788,23 @@ private static bool TryFromString<TDest>(string? value, out TDest? result)
 		where TDest : SemanticString<TDest>
 	{
 		result = null;
+		if (value is null)
+		{
+			return false;
+		}
+
+		// A rejected value is the expected case here, so it is reported by the return value rather than by an
+		// exception, and its reasons are never put into words (#443). The catch is only for a MakeCanonical or a
+		// validator that rejects its input by throwing, as Create would report it.
 		try
 		{
-			if (value is null)
+			TDest instance = FromStringInternal<TDest>(value);
+			if (!instance.IsValid())
 			{
 				return false;
 			}
 
-			result = Create<TDest>(value);
+			result = instance;
 			return true;
 		}
 		catch (ArgumentException)
@@ -825,23 +826,7 @@ private static bool TryFromString<TDest>(string? value, out TDest? result)
 	/// </remarks>
 	private static bool TryFromCharArray<TDest>(char[]? value, out TDest? result)
 		where TDest : SemanticString<TDest>
-	{
-		result = null;
-		try
-		{
-			if (value is null)
-			{
-				return false;
-			}
-
-			result = Create<TDest>(value);
-			return true;
-		}
-		catch (ArgumentException)
-		{
-			return false;
-		}
-	}
+		=> TryFromString(value is null ? null : new string(value: value), out result);
 
 	/// <summary>
 	/// Attempts to create a new instance of the specified semantic string type from a read-only character span without throwing exceptions.
@@ -857,18 +842,7 @@ private static bool TryFromCharArray<TDest>(char[]? value, out TDest? result)
 	/// </remarks>
 	private static bool TryFromReadOnlySpan<TDest>(ReadOnlySpan<char> value, out TDest? result)
 		where TDest : SemanticString<TDest>
-	{
-		result = null;
-		try
-		{
-			result = Create<TDest>(value);
-			return true;
-		}
-		catch (ArgumentException)
-		{
-			return false;
-		}
-	}
+		=> TryFromString(value.ToString(), out result);
 
 	/// <summary>
 	/// Gets this semantic string as a read-only span without allocation.
diff --git a/Semantics.Strings/Validation/SemanticStringValidationAttributes.cs b/Semantics.Strings/Validation/SemanticStringValidationAttributes.cs
index 360c80bd..c4e38ec0 100644
--- a/Semantics.Strings/Validation/SemanticStringValidationAttributes.cs
+++ b/Semantics.Strings/Validation/SemanticStringValidationAttributes.cs
@@ -42,8 +42,7 @@ public static IEnumerable<string> GetValidationErrors(ISemanticString semanticSt
 	{
 		Ensure.NotNull(type);
 
-		foreach (SemanticStringValidationAttribute attribute in type.GetCustomAttributes(typeof(SemanticStringValidationAttribute), true)
-			.Cast<SemanticStringValidationAttribute>()
+		foreach (SemanticStringValidationAttribute attribute in ValidationAttributeCache.Attributes(type)
 			.Where(attribute => !attribute.Validate(semanticString)))
 		{
 			string[] errors = attribute is NativeSemanticStringValidationAttribute native
diff --git a/Semantics.Strings/Validation/Strategies/ValidateAllStrategy.cs b/Semantics.Strings/Validation/Strategies/ValidateAllStrategy.cs
index b066bdb8..d60e936a 100644
--- a/Semantics.Strings/Validation/Strategies/ValidateAllStrategy.cs
+++ b/Semantics.Strings/Validation/Strategies/ValidateAllStrategy.cs
@@ -12,8 +12,20 @@ public bool Validate(ISemanticString semanticString, Type type)
 	{
 		Ensure.NotNull(type);
 
-		SemanticStringValidationAttribute[] validationAttributes = [.. type.GetCustomAttributes(typeof(SemanticStringValidationAttribute), true)
-			.Cast<SemanticStringValidationAttribute>()];
-		return validationAttributes.Length == 0 || validationAttributes.All(attr => attr.Validate(semanticString));
+		SemanticStringValidationAttribute[] validationAttributes = ValidationAttributeCache.Attributes(type);
+		if (validationAttributes.Length == 0)
+		{
+			return true;
+		}
+
+		foreach (SemanticStringValidationAttribute attribute in validationAttributes)
+		{
+			if (!attribute.Validate(semanticString))
+			{
+				return false;
+			}
+		}
+
+		return true;
 	}
 }
diff --git a/Semantics.Strings/Validation/Strategies/ValidateAnyStrategy.cs b/Semantics.Strings/Validation/Strategies/ValidateAnyStrategy.cs
index b9ec47f3..6ae4af4b 100644
--- a/Semantics.Strings/Validation/Strategies/ValidateAnyStrategy.cs
+++ b/Semantics.Strings/Validation/Strategies/ValidateAnyStrategy.cs
@@ -12,8 +12,20 @@ public bool Validate(ISemanticString semanticString, Type type)
 	{
 		Ensure.NotNull(type);
 
-		SemanticStringValidationAttribute[] validationAttributes = [.. type.GetCustomAttributes(typeof(SemanticStringValidationAttribute), true)
-			.Cast<SemanticStringValidationAttribute>()];
-		return validationAttributes.Length == 0 || validationAttributes.Any(attr => attr.Validate(semanticString));
+		SemanticStringValidationAttribute[] validationAttributes = ValidationAttributeCache.Attributes(type);
+		if (validationAttributes.Length == 0)
+		{
+			return true;
+		}
+
+		foreach (SemanticStringValidationAttribute attribute in validationAttributes)
+		{
+			if (attribute.Validate(semanticString))
+			{
+				return true;
+			}
+		}
+
+		return false;
 	}
 }
diff --git a/Semantics.Strings/Validation/Strategies/ValidationStrategyFactory.cs b/Semantics.Strings/Validation/Strategies/ValidationStrategyFactory.cs
index 3d486644..ebdb2008 100644
--- a/Semantics.Strings/Validation/Strategies/ValidationStrategyFactory.cs
+++ b/Semantics.Strings/Validation/Strategies/ValidationStrategyFactory.cs
@@ -19,8 +19,6 @@ public static IValidationStrategy CreateStrategy(Type type)
 	{
 		Ensure.NotNull(type);
 
-		// Check for ValidateAny attribute
-		object[] validateAnyAttributes = type.GetCustomAttributes(typeof(ValidateAnyAttribute), true);
-		return validateAnyAttributes.Length > 0 ? AnyStrategy : AllStrategy;
+		return ValidationAttributeCache.ValidatesAny(type) ? AnyStrategy : AllStrategy;
 	}
 }
diff --git a/Semantics.Strings/Validation/ValidationAttributeCache.cs b/Semantics.Strings/Validation/ValidationAttributeCache.cs
new file mode 100644
index 00000000..49548ecc
--- /dev/null
+++ b/Semantics.Strings/Validation/ValidationAttributeCache.cs
@@ -0,0 +1,41 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Strings;
+
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+
+/// <summary>
+/// The validation attributes a semantic string type declares, read once per type.
+/// </summary>
+/// <remarks>
+/// <see cref="Attribute.GetCustomAttributes(System.Reflection.MemberInfo, Type, bool)"/> builds new attribute
+/// instances on every call, and each <see cref="NativeSemanticStringValidationAttribute"/> builds its validator
+/// lazily, so reading them per value allocated a validator per value validated (#444). Attributes are
+/// immutable once constructed and their validators are stateless, so one set per type serves every thread.
+/// </remarks>
+internal static class ValidationAttributeCache
+{
+	private static readonly ConcurrentDictionary<Type, Entry> Entries = new();
+
+	/// <summary>Gets the validation attributes declared on a type and its bases, in declaration order.</summary>
+	/// <param name="type">The semantic string type.</param>
+	/// <returns>The attributes, shared between callers; do not modify the array.</returns>
+	public static SemanticStringValidationAttribute[] Attributes(Type type) => Get(type).Attributes;
+
+	/// <summary>Gets whether a type is marked <see cref="ValidateAnyAttribute"/>.</summary>
+	/// <param name="type">The semantic string type.</param>
+	/// <returns><see langword="true"/> when any one attribute passing is enough.</returns>
+	public static bool ValidatesAny(Type type) => Get(type).ValidatesAny;
+
+	private static Entry Get(Type type)
+	{
+		Ensure.NotNull(type);
+		return Entries.GetOrAdd(type, static t => new Entry(
+			[.. t.GetCustomAttributes(typeof(SemanticStringValidationAttribute), true).Cast<SemanticStringValidationAttribute>()],
+			t.GetCustomAttributes(typeof(ValidateAnyAttribute), true).Length > 0));
+	}
+
+	private sealed record Entry(SemanticStringValidationAttribute[] Attributes, bool ValidatesAny);
+}
diff --git a/Semantics.Test/SemanticStringCreationCostTests.cs b/Semantics.Test/SemanticStringCreationCostTests.cs
new file mode 100644
index 00000000..30dc2765
--- /dev/null
+++ b/Semantics.Test/SemanticStringCreationCostTests.cs
@@ -0,0 +1,69 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Semantics.Test;
+
+using System;
+using System.Runtime.ExceptionServices;
+using ktsu.Semantics.Strings;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Issue #443: rejecting a value through <c>TryCreate</c> throws nothing. Issue #444: a type's validation
+/// attributes are read once rather than per value.
+/// </summary>
+[TestClass]
+public sealed class SemanticStringCreationCostTests
+{
+	[ThreadStatic]
+	private static int exceptionsOnThisThread;
+
+	private static void Count(object? sender, FirstChanceExceptionEventArgs e) => exceptionsOnThisThread++;
+
+	[TestMethod]
+	public void TryCreate_RejectsWithoutThrowing()
+	{
+		AppDomain.CurrentDomain.FirstChanceException += Count;
+		try
+		{
+			exceptionsOnThisThread = 0;
+
+			bool fromString = StartsWithValidSemanticString.TryCreate("Nope", out StartsWithValidSemanticString? a);
+			bool fromChars = StartsWithValidSemanticString.TryCreate("Nope".ToCharArray(), out StartsWithValidSemanticString? b);
+			bool fromSpan = StartsWithValidSemanticString.TryCreate("Nope".AsSpan(), out StartsWithValidSemanticString? c);
+			bool fromNull = StartsWithValidSemanticString.TryCreate((string?)null, out StartsWithValidSemanticString? d);
+
+			Assert.IsFalse(fromString || fromChars || fromSpan || fromNull);
+			Assert.IsNull(a ?? b ?? c ?? d);
+			Assert.AreEqual(0, exceptionsOnThisThread);
+		}
+		finally
+		{
+			AppDomain.CurrentDomain.FirstChanceException -= Count;
+		}
+	}
+
+	[TestMethod]
+	public void TryCreate_AcceptsAValidValue()
+	{
+		Assert.IsTrue(StartsWithValidSemanticString.TryCreate("Valid value", out StartsWithValidSemanticString? result));
+		Assert.AreEqual("Valid value", result?.WeakString);
+	}
+
+	[TestMethod]
+	public void Create_StillThrowsWithTheReasons()
+	{
+		ArgumentException error = Assert.ThrowsExactly<ArgumentException>(() => StartsWithValidSemanticString.Create("Nope"));
+		StringAssert.Contains(error.Message, "\"Nope\"");
+		StringAssert.Contains(error.Message, nameof(StartsWithValidSemanticString));
+	}
+
+	[TestMethod]
+	public void ValidationAttributes_AreReadOncePerType()
+	{
+		Type type = typeof(StartsWithValidSemanticString);
+		SemanticStringValidationAttribute[] first = ValidationAttributeCache.Attributes(type);
+
+		Assert.HasCount(1, first);
+		Assert.AreSame(first, ValidationAttributeCache.Attributes(type));
+	}
+}

From 117b10406803f3616e6c94359a17e9d9f50f9635 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 11:01:02 +0000
Subject: [PATCH 7/8] Use Path.Join for test fixture paths

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 Semantics.Test/Paths/DotSegmentPathTests.cs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Semantics.Test/Paths/DotSegmentPathTests.cs b/Semantics.Test/Paths/DotSegmentPathTests.cs
index 9bcf78fb..df45d463 100644
--- a/Semantics.Test/Paths/DotSegmentPathTests.cs
+++ b/Semantics.Test/Paths/DotSegmentPathTests.cs
@@ -147,13 +147,13 @@ protected override IFilePath CreateFilePath(string filePath) =>
 	[TestMethod]
 	public void GetContents_SkipsAnEntryThatFailsValidation()
 	{
-		string root = Path.Combine(Path.GetTempPath(), "semantics-contents-" + Guid.NewGuid().ToString("N"));
+		string root = Path.Join(Path.GetTempPath(), "semantics-contents-" + Guid.NewGuid().ToString("N"));
 		Directory.CreateDirectory(root);
 		try
 		{
-			File.WriteAllText(Path.Combine(root, "ok.txt"), "ok");
-			Directory.CreateDirectory(Path.Combine(root, "sub"));
-			File.WriteAllText(Path.Combine(root, "bad.txt"), "rejected");
+			File.WriteAllText(Path.Join(root, "ok.txt"), "ok");
+			Directory.CreateDirectory(Path.Join(root, "sub"));
+			File.WriteAllText(Path.Join(root, "bad.txt"), "rejected");
 
 			PickyDirectoryPath dir = PickyDirectoryPath.Create<PickyDirectoryPath>(root);
 			List<string> names = [.. dir.GetContents().Select(p => Path.GetFileName(p.ToString()) ?? "")];
@@ -172,13 +172,13 @@ public void GetContents_SkipsAnEntryThatFailsValidation()
 	[TestCategory("OS-Specific")]
 	public void GetContents_SkipsAnEntryPastTheWindowsLengthLimit()
 	{
-		string root = Path.Combine(Path.GetTempPath(), "semantics-contents-" + Guid.NewGuid().ToString("N"));
+		string root = Path.Join(Path.GetTempPath(), "semantics-contents-" + Guid.NewGuid().ToString("N"));
 		Directory.CreateDirectory(root);
 		try
 		{
-			File.WriteAllText(Path.Combine(root, "ok.txt"), "ok");
-			Directory.CreateDirectory(Path.Combine(root, "sub"));
-			File.WriteAllText(Path.Combine(root, new string('x', 250) + ".txt"), "too long");
+			File.WriteAllText(Path.Join(root, "ok.txt"), "ok");
+			Directory.CreateDirectory(Path.Join(root, "sub"));
+			File.WriteAllText(Path.Join(root, new string('x', 250) + ".txt"), "too long");
 
 			List<string> names = [.. Absolute(root).GetContents().Select(p => Path.GetFileName(p.ToString()) ?? "")];
 

From 8134f226b03c201e563079be091356e2e3283a27 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 26 Oct 2026 11:05:35 +0000
Subject: [PATCH 8/8] Address code-quality findings: zero pattern, local
 exception counter, explicit Where

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RjhaUGAEJWfvbkaV4MjYkY
---
 Semantics.Quantities/StorageLiteral.cs          |  2 +-
 .../Quantities/GeneratorOutputInvariantTests.cs |  8 +++-----
 .../SemanticStringCreationCostTests.cs          | 17 +++++++++++------
 3 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/Semantics.Quantities/StorageLiteral.cs b/Semantics.Quantities/StorageLiteral.cs
index 4026a84e..231cfedd 100644
--- a/Semantics.Quantities/StorageLiteral.cs
+++ b/Semantics.Quantities/StorageLiteral.cs
@@ -105,7 +105,7 @@ internal static T Constant<T>(string literal, string name)
 		double expected = double.Parse(literal, NumberStyles.Float, CultureInfo.InvariantCulture);
 		T value = TryParseLiteral(literal, out T parsed) ? parsed : T.CreateChecked(expected);
 
-		if (expected != 0.0 && !KeepsPrecision(value, expected))
+		if (expected is not 0.0 && !KeepsPrecision(value, expected))
 		{
 			throw new ArithmeticException(string.Format(
 				CultureInfo.InvariantCulture,
diff --git a/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs b/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs
index 5ff977f2..868bf050 100644
--- a/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs
+++ b/Semantics.Test/Quantities/GeneratorOutputInvariantTests.cs
@@ -102,12 +102,10 @@ public void EveryCrossDimensionalMultiplicationHasBothOperandOrders()
 		Dictionary<string, string> baseOf = [];
 		foreach (Type type in types)
 		{
-			foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly))
+			foreach (MethodInfo m in type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly)
+				.Where(m => m.Name == "op_Implicit" && m.GetParameters()[0].ParameterType.Name == type.Name && m.ReturnType.Namespace == type.Namespace))
 			{
-				if (m.Name == "op_Implicit" && m.GetParameters()[0].ParameterType.Name == type.Name && m.ReturnType.Namespace == type.Namespace)
-				{
-					baseOf[type.Name] = m.ReturnType.Name;
-				}
+				baseOf[type.Name] = m.ReturnType.Name;
 			}
 		}
 
diff --git a/Semantics.Test/SemanticStringCreationCostTests.cs b/Semantics.Test/SemanticStringCreationCostTests.cs
index 30dc2765..68a261eb 100644
--- a/Semantics.Test/SemanticStringCreationCostTests.cs
+++ b/Semantics.Test/SemanticStringCreationCostTests.cs
@@ -14,18 +14,23 @@ namespace ktsu.Semantics.Test;
 [TestClass]
 public sealed class SemanticStringCreationCostTests
 {
-	[ThreadStatic]
-	private static int exceptionsOnThisThread;
-
-	private static void Count(object? sender, FirstChanceExceptionEventArgs e) => exceptionsOnThisThread++;
-
 	[TestMethod]
 	public void TryCreate_RejectsWithoutThrowing()
 	{
+		// Tests run in parallel, so only exceptions thrown on this test's own thread count.
+		int thisThread = Environment.CurrentManagedThreadId;
+		int exceptionsOnThisThread = 0;
+		void Count(object? sender, FirstChanceExceptionEventArgs e)
+		{
+			if (Environment.CurrentManagedThreadId == thisThread)
+			{
+				exceptionsOnThisThread++;
+			}
+		}
+
 		AppDomain.CurrentDomain.FirstChanceException += Count;
 		try
 		{
-			exceptionsOnThisThread = 0;
 
 			bool fromString = StartsWithValidSemanticString.TryCreate("Nope", out StartsWithValidSemanticString? a);
 			bool fromChars = StartsWithValidSemanticString.TryCreate("Nope".ToCharArray(), out StartsWithValidSemanticString? b);