diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs
index cfd64f6..5ca1e49 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AbsorbedDose.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AbsorbedDose<T> operator +(AbsorbedDose<T> left, AbsorbedDose<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AbsorbedDose{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AbsorbedDose{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AbsorbedDose<T> operator -(AbsorbedDose<T> value) => Create(-value.Quantity);
+	public static AbsorbedDose<T> operator *(AbsorbedDose<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AbsorbedDose{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AbsorbedDose{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AbsorbedDose<T> operator *(AbsorbedDose<T> left, T right) => Create(left.Quantity * right);
+	public static AbsorbedDose<T> operator *(T left, AbsorbedDose<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AbsorbedDose{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AbsorbedDose{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AbsorbedDose<T> operator *(T left, AbsorbedDose<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AbsorbedDose{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AbsorbedDose<T> operator /(AbsorbedDose<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AbsorbedDose<T> operator /(AbsorbedDose<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AbsorbedDose{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 1f328f0..5705be0 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AccelerationMagnitude<T> operator +(AccelerationMagnitude<T> left, AccelerationMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AccelerationMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AccelerationMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator -(AccelerationMagnitude<T> value) => Create(-value.Quantity);
+	public static AccelerationMagnitude<T> operator *(AccelerationMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AccelerationMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AccelerationMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator *(AccelerationMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static AccelerationMagnitude<T> operator *(T left, AccelerationMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AccelerationMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AccelerationMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator *(T left, AccelerationMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AccelerationMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AccelerationMagnitude<T> operator /(AccelerationMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AccelerationMagnitude<T> operator /(AccelerationMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AccelerationMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs
index d1dd552..40e02e9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AcousticImpedance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AcousticImpedance<T> operator +(AcousticImpedance<T> left, AcousticImpedance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AcousticImpedance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AcousticImpedance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AcousticImpedance<T> operator -(AcousticImpedance<T> value) => Create(-value.Quantity);
+	public static AcousticImpedance<T> operator *(AcousticImpedance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AcousticImpedance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AcousticImpedance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AcousticImpedance<T> operator *(AcousticImpedance<T> left, T right) => Create(left.Quantity * right);
+	public static AcousticImpedance<T> operator *(T left, AcousticImpedance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AcousticImpedance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AcousticImpedance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AcousticImpedance<T> operator *(T left, AcousticImpedance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AcousticImpedance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AcousticImpedance<T> operator /(AcousticImpedance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AcousticImpedance<T> operator /(AcousticImpedance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AcousticImpedance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 dc62d47..2a2f660 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ActivationEnergy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ActivationEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ActivationEnergy<T> operator -(ActivationEnergy<T> value) => Create(-value.Quantity);
+	public static ActivationEnergy<T> operator *(ActivationEnergy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ActivationEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ActivationEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ActivationEnergy<T> operator *(ActivationEnergy<T> left, T right) => Create(left.Quantity * right);
+	public static ActivationEnergy<T> operator *(T left, ActivationEnergy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ActivationEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ActivationEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ActivationEnergy<T> operator *(T left, ActivationEnergy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ActivationEnergy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ActivationEnergy<T> operator /(ActivationEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ActivationEnergy<T> operator /(ActivationEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ActivationEnergy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 62d1083..9f43107 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Admittance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Admittance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Admittance<T> operator -(Admittance<T> value) => Create(-value.Quantity);
+	public static Admittance<T> operator *(Admittance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Admittance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Admittance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Admittance<T> operator *(Admittance<T> left, T right) => Create(left.Quantity * right);
+	public static Admittance<T> operator *(T left, Admittance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Admittance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Admittance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Admittance<T> operator *(T left, Admittance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Admittance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Admittance<T> operator /(Admittance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Admittance<T> operator /(Admittance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Admittance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 6755b9f..ad1418b 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Airspeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Airspeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Airspeed<T> operator -(Airspeed<T> value) => Create(-value.Quantity);
+	public static Airspeed<T> operator *(Airspeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Airspeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Airspeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Airspeed<T> operator *(Airspeed<T> left, T right) => Create(left.Quantity * right);
+	public static Airspeed<T> operator *(T left, Airspeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Airspeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Airspeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Airspeed<T> operator *(T left, Airspeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Airspeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Airspeed<T> operator /(Airspeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Airspeed<T> operator /(Airspeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Airspeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 07fd0f4..daca655 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Altitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Altitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Altitude<T> operator -(Altitude<T> value) => Create(-value.Quantity);
+	public static Altitude<T> operator *(Altitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Altitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Altitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Altitude<T> operator *(Altitude<T> left, T right) => Create(left.Quantity * right);
+	public static Altitude<T> operator *(T left, Altitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Altitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Altitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Altitude<T> operator *(T left, Altitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Altitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Altitude<T> operator /(Altitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Altitude<T> operator /(Altitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Altitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 2a88d95..e903fd6 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AmountOfSubstance<T> operator +(AmountOfSubstance<T> left, AmountOfSubstance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AmountOfSubstance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AmountOfSubstance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AmountOfSubstance<T> operator -(AmountOfSubstance<T> value) => Create(-value.Quantity);
+	public static AmountOfSubstance<T> operator *(AmountOfSubstance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AmountOfSubstance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AmountOfSubstance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AmountOfSubstance<T> operator *(AmountOfSubstance<T> left, T right) => Create(left.Quantity * right);
+	public static AmountOfSubstance<T> operator *(T left, AmountOfSubstance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AmountOfSubstance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AmountOfSubstance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AmountOfSubstance<T> operator *(T left, AmountOfSubstance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AmountOfSubstance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AmountOfSubstance<T> operator /(AmountOfSubstance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AmountOfSubstance<T> operator /(AmountOfSubstance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AmountOfSubstance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 987159b..a8722d6 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Angle<T> operator +(Angle<T> left, Angle<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Angle{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Angle{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Angle<T> operator -(Angle<T> value) => Create(-value.Quantity);
+	public static Angle<T> operator *(Angle<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Angle{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Angle{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Angle<T> operator *(Angle<T> left, T right) => Create(left.Quantity * right);
+	public static Angle<T> operator *(T left, Angle<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Angle{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Angle{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Angle<T> operator *(T left, Angle<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Angle{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Angle<T> operator /(Angle<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Angle<T> operator /(Angle<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Angle{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5528dd5..7787eed 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AngularAccelerationMagnitude<T> operator +(AngularAccelerationMagnitude<T> left, AngularAccelerationMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AngularAccelerationMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AngularAccelerationMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularAccelerationMagnitude<T> operator -(AngularAccelerationMagnitude<T> value) => Create(-value.Quantity);
+	public static AngularAccelerationMagnitude<T> operator *(AngularAccelerationMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AngularAccelerationMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AngularAccelerationMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularAccelerationMagnitude<T> operator *(AngularAccelerationMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static AngularAccelerationMagnitude<T> operator *(T left, AngularAccelerationMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AngularAccelerationMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AngularAccelerationMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularAccelerationMagnitude<T> operator *(T left, AngularAccelerationMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AngularAccelerationMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularAccelerationMagnitude<T> operator /(AngularAccelerationMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AngularAccelerationMagnitude<T> operator /(AngularAccelerationMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AngularAccelerationMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs
index dca935e..7bbb74a 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/AngularJerkMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AngularJerkMagnitude<T> operator +(AngularJerkMagnitude<T> left, AngularJerkMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AngularJerkMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AngularJerkMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularJerkMagnitude<T> operator -(AngularJerkMagnitude<T> value) => Create(-value.Quantity);
+	public static AngularJerkMagnitude<T> operator *(AngularJerkMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AngularJerkMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AngularJerkMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularJerkMagnitude<T> operator *(AngularJerkMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static AngularJerkMagnitude<T> operator *(T left, AngularJerkMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AngularJerkMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AngularJerkMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularJerkMagnitude<T> operator *(T left, AngularJerkMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AngularJerkMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularJerkMagnitude<T> operator /(AngularJerkMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AngularJerkMagnitude<T> operator /(AngularJerkMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AngularJerkMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 7443c16..72f2afb 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AngularMomentumMagnitude<T> operator +(AngularMomentumMagnitude<T> left, AngularMomentumMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AngularMomentumMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AngularMomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularMomentumMagnitude<T> operator -(AngularMomentumMagnitude<T> value) => Create(-value.Quantity);
+	public static AngularMomentumMagnitude<T> operator *(AngularMomentumMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AngularMomentumMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AngularMomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularMomentumMagnitude<T> operator *(AngularMomentumMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static AngularMomentumMagnitude<T> operator *(T left, AngularMomentumMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AngularMomentumMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AngularMomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularMomentumMagnitude<T> operator *(T left, AngularMomentumMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AngularMomentumMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularMomentumMagnitude<T> operator /(AngularMomentumMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AngularMomentumMagnitude<T> operator /(AngularMomentumMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AngularMomentumMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 9fc2934..8e34672 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static AngularSpeed<T> operator +(AngularSpeed<T> left, AngularSpeed<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AngularSpeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AngularSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularSpeed<T> operator -(AngularSpeed<T> value) => Create(-value.Quantity);
+	public static AngularSpeed<T> operator *(AngularSpeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AngularSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AngularSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularSpeed<T> operator *(AngularSpeed<T> left, T right) => Create(left.Quantity * right);
+	public static AngularSpeed<T> operator *(T left, AngularSpeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AngularSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AngularSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularSpeed<T> operator *(T left, AngularSpeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AngularSpeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AngularSpeed<T> operator /(AngularSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AngularSpeed<T> operator /(AngularSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AngularSpeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 2a2778a..00d656a 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ApertureAngle{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ApertureAngle{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ApertureAngle<T> operator -(ApertureAngle<T> value) => Create(-value.Quantity);
+	public static ApertureAngle<T> operator *(ApertureAngle<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ApertureAngle{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ApertureAngle{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ApertureAngle<T> operator *(ApertureAngle<T> left, T right) => Create(left.Quantity * right);
+	public static ApertureAngle<T> operator *(T left, ApertureAngle<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ApertureAngle{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ApertureAngle{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ApertureAngle<T> operator *(T left, ApertureAngle<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ApertureAngle{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ApertureAngle<T> operator /(ApertureAngle<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ApertureAngle<T> operator /(ApertureAngle<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ApertureAngle{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 cabd793..d3d081e 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Area<T> operator +(Area<T> left, Area<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Area{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Area{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator -(Area<T> value) => Create(-value.Quantity);
+	public static Area<T> operator *(Area<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Area{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Area{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator *(Area<T> left, T right) => Create(left.Quantity * right);
+	public static Area<T> operator *(T left, Area<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Area{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Area{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator *(T left, Area<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Area{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Area<T> operator /(Area<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Area<T> operator /(Area<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Area{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 d165c15..2f31833 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AtmosphericPressure{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AtmosphericPressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtmosphericPressure<T> operator -(AtmosphericPressure<T> value) => Create(-value.Quantity);
+	public static AtmosphericPressure<T> operator *(AtmosphericPressure<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AtmosphericPressure{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AtmosphericPressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtmosphericPressure<T> operator *(AtmosphericPressure<T> left, T right) => Create(left.Quantity * right);
+	public static AtmosphericPressure<T> operator *(T left, AtmosphericPressure<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AtmosphericPressure{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AtmosphericPressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtmosphericPressure<T> operator *(T left, AtmosphericPressure<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AtmosphericPressure{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtmosphericPressure<T> operator /(AtmosphericPressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AtmosphericPressure<T> operator /(AtmosphericPressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AtmosphericPressure{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 a8589c4..4707aea 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="AtomicMass{T}"/>.</summary>
+	/// <summary>Scales a <see cref="AtomicMass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtomicMass<T> operator -(AtomicMass<T> value) => Create(-value.Quantity);
+	public static AtomicMass<T> operator *(AtomicMass<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="AtomicMass{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="AtomicMass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtomicMass<T> operator *(AtomicMass<T> left, T right) => Create(left.Quantity * right);
+	public static AtomicMass<T> operator *(T left, AtomicMass<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="AtomicMass{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="AtomicMass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtomicMass<T> operator *(T left, AtomicMass<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="AtomicMass{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static AtomicMass<T> operator /(AtomicMass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static AtomicMass<T> operator /(AtomicMass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="AtomicMass{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 aa0aefb..487d02e 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Bandwidth{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Bandwidth{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Bandwidth<T> operator -(Bandwidth<T> value) => Create(-value.Quantity);
+	public static Bandwidth<T> operator *(Bandwidth<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Bandwidth{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Bandwidth{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Bandwidth<T> operator *(Bandwidth<T> left, T right) => Create(left.Quantity * right);
+	public static Bandwidth<T> operator *(T left, Bandwidth<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Bandwidth{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Bandwidth{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Bandwidth<T> operator *(T left, Bandwidth<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Bandwidth{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Bandwidth<T> operator /(Bandwidth<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Bandwidth<T> operator /(Bandwidth<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Bandwidth{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 db2819d..658b561 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="BulkModulus{T}"/>.</summary>
+	/// <summary>Scales a <see cref="BulkModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static BulkModulus<T> operator -(BulkModulus<T> value) => Create(-value.Quantity);
+	public static BulkModulus<T> operator *(BulkModulus<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="BulkModulus{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="BulkModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static BulkModulus<T> operator *(BulkModulus<T> left, T right) => Create(left.Quantity * right);
+	public static BulkModulus<T> operator *(T left, BulkModulus<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="BulkModulus{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="BulkModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static BulkModulus<T> operator *(T left, BulkModulus<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="BulkModulus{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static BulkModulus<T> operator /(BulkModulus<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static BulkModulus<T> operator /(BulkModulus<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="BulkModulus{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs
index f3b5e9f..e13f9b9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Capacitance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Capacitance<T> operator +(Capacitance<T> left, Capacitance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Capacitance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Capacitance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacitance<T> operator -(Capacitance<T> value) => Create(-value.Quantity);
+	public static Capacitance<T> operator *(Capacitance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Capacitance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Capacitance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacitance<T> operator *(Capacitance<T> left, T right) => Create(left.Quantity * right);
+	public static Capacitance<T> operator *(T left, Capacitance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Capacitance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Capacitance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacitance<T> operator *(T left, Capacitance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Capacitance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacitance<T> operator /(Capacitance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Capacitance<T> operator /(Capacitance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Capacitance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 e4399a7..c06801b 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Capacity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Capacity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacity<T> operator -(Capacity<T> value) => Create(-value.Quantity);
+	public static Capacity<T> operator *(Capacity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Capacity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Capacity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacity<T> operator *(Capacity<T> left, T right) => Create(left.Quantity * right);
+	public static Capacity<T> operator *(T left, Capacity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Capacity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Capacity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacity<T> operator *(T left, Capacity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Capacity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Capacity<T> operator /(Capacity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Capacity<T> operator /(Capacity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Capacity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs
index 7bccb41..84fb483 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/CatalyticActivity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static CatalyticActivity<T> operator +(CatalyticActivity<T> left, CatalyticActivity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="CatalyticActivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="CatalyticActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CatalyticActivity<T> operator -(CatalyticActivity<T> value) => Create(-value.Quantity);
+	public static CatalyticActivity<T> operator *(CatalyticActivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="CatalyticActivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="CatalyticActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CatalyticActivity<T> operator *(CatalyticActivity<T> left, T right) => Create(left.Quantity * right);
+	public static CatalyticActivity<T> operator *(T left, CatalyticActivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="CatalyticActivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="CatalyticActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CatalyticActivity<T> operator *(T left, CatalyticActivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="CatalyticActivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CatalyticActivity<T> operator /(CatalyticActivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static CatalyticActivity<T> operator /(CatalyticActivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="CatalyticActivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 279136c..1154b02 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ChargeMagnitude<T> operator +(ChargeMagnitude<T> left, ChargeMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ChargeMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ChargeMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ChargeMagnitude<T> operator -(ChargeMagnitude<T> value) => Create(-value.Quantity);
+	public static ChargeMagnitude<T> operator *(ChargeMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ChargeMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ChargeMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ChargeMagnitude<T> operator *(ChargeMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static ChargeMagnitude<T> operator *(T left, ChargeMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ChargeMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ChargeMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ChargeMagnitude<T> operator *(T left, ChargeMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ChargeMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ChargeMagnitude<T> operator /(ChargeMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ChargeMagnitude<T> operator /(ChargeMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ChargeMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 75eb268..7b5f4ea 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ClockSpeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ClockSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ClockSpeed<T> operator -(ClockSpeed<T> value) => Create(-value.Quantity);
+	public static ClockSpeed<T> operator *(ClockSpeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ClockSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ClockSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ClockSpeed<T> operator *(ClockSpeed<T> left, T right) => Create(left.Quantity * right);
+	public static ClockSpeed<T> operator *(T left, ClockSpeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ClockSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ClockSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ClockSpeed<T> operator *(T left, ClockSpeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ClockSpeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ClockSpeed<T> operator /(ClockSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ClockSpeed<T> operator /(ClockSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ClockSpeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 2e37a81..b0436a0 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Concentration<T> operator +(Concentration<T> left, Concentration<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Concentration{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Concentration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Concentration<T> operator -(Concentration<T> value) => Create(-value.Quantity);
+	public static Concentration<T> operator *(Concentration<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Concentration{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Concentration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Concentration<T> operator *(Concentration<T> left, T right) => Create(left.Quantity * right);
+	public static Concentration<T> operator *(T left, Concentration<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Concentration{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Concentration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Concentration<T> operator *(T left, Concentration<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Concentration{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Concentration<T> operator /(Concentration<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Concentration<T> operator /(Concentration<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Concentration{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs
index 9a1db24..1bb1a0c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Conductance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Conductance<T> operator +(Conductance<T> left, Conductance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Conductance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Conductance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Conductance<T> operator -(Conductance<T> value) => Create(-value.Quantity);
+	public static Conductance<T> operator *(Conductance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Conductance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Conductance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Conductance<T> operator *(Conductance<T> left, T right) => Create(left.Quantity * right);
+	public static Conductance<T> operator *(T left, Conductance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Conductance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Conductance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Conductance<T> operator *(T left, Conductance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Conductance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Conductance<T> operator /(Conductance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Conductance<T> operator /(Conductance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Conductance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 4989e0f..dacce60 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="CrossSectionalArea{T}"/>.</summary>
+	/// <summary>Scales a <see cref="CrossSectionalArea{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CrossSectionalArea<T> operator -(CrossSectionalArea<T> value) => Create(-value.Quantity);
+	public static CrossSectionalArea<T> operator *(CrossSectionalArea<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="CrossSectionalArea{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="CrossSectionalArea{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CrossSectionalArea<T> operator *(CrossSectionalArea<T> left, T right) => Create(left.Quantity * right);
+	public static CrossSectionalArea<T> operator *(T left, CrossSectionalArea<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="CrossSectionalArea{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="CrossSectionalArea{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CrossSectionalArea<T> operator *(T left, CrossSectionalArea<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="CrossSectionalArea{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CrossSectionalArea<T> operator /(CrossSectionalArea<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static CrossSectionalArea<T> operator /(CrossSectionalArea<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="CrossSectionalArea{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 69a84c6..b368a55 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static CurrentMagnitude<T> operator +(CurrentMagnitude<T> left, CurrentMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="CurrentMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="CurrentMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator -(CurrentMagnitude<T> value) => Create(-value.Quantity);
+	public static CurrentMagnitude<T> operator *(CurrentMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="CurrentMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="CurrentMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator *(CurrentMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static CurrentMagnitude<T> operator *(T left, CurrentMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="CurrentMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="CurrentMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator *(T left, CurrentMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="CurrentMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static CurrentMagnitude<T> operator /(CurrentMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static CurrentMagnitude<T> operator /(CurrentMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="CurrentMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 3c2e0ff..355641c 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="DecayTime{T}"/>.</summary>
+	/// <summary>Scales a <see cref="DecayTime{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DecayTime<T> operator -(DecayTime<T> value) => Create(-value.Quantity);
+	public static DecayTime<T> operator *(DecayTime<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="DecayTime{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="DecayTime{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DecayTime<T> operator *(DecayTime<T> left, T right) => Create(left.Quantity * right);
+	public static DecayTime<T> operator *(T left, DecayTime<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="DecayTime{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="DecayTime{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DecayTime<T> operator *(T left, DecayTime<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="DecayTime{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DecayTime<T> operator /(DecayTime<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static DecayTime<T> operator /(DecayTime<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="DecayTime{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs
index cce24a6..ab7291f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Density.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Density<T> operator +(Density<T> left, Density<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Density{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Density{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Density<T> operator -(Density<T> value) => Create(-value.Quantity);
+	public static Density<T> operator *(Density<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Density{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Density{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Density<T> operator *(Density<T> left, T right) => Create(left.Quantity * right);
+	public static Density<T> operator *(T left, Density<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Density{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Density{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Density<T> operator *(T left, Density<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Density{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Density<T> operator /(Density<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Density<T> operator /(Density<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Density{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5a6a27c..965da4c 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Depth{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Depth{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Depth<T> operator -(Depth<T> value) => Create(-value.Quantity);
+	public static Depth<T> operator *(Depth<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Depth{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Depth{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Depth<T> operator *(Depth<T> left, T right) => Create(left.Quantity * right);
+	public static Depth<T> operator *(T left, Depth<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Depth{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Depth{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Depth<T> operator *(T left, Depth<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Depth{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Depth<T> operator /(Depth<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Depth<T> operator /(Depth<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Depth{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 3645ac9..0ddbc05 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
@@ -54,21 +54,17 @@ 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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Diameter{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Diameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Diameter<T> operator -(Diameter<T> value) => Create(-value.Quantity);
+	public static Diameter<T> operator *(Diameter<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Diameter{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Diameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Diameter<T> operator *(Diameter<T> left, T right) => Create(left.Quantity * right);
+	public static Diameter<T> operator *(T left, Diameter<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Diameter{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Diameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Diameter<T> operator *(T left, Diameter<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Diameter{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Diameter<T> operator /(Diameter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Diameter<T> operator /(Diameter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Diameter{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 8c33534..19b0926 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Distance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Distance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Distance<T> operator -(Distance<T> value) => Create(-value.Quantity);
+	public static Distance<T> operator *(Distance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Distance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Distance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Distance<T> operator *(Distance<T> left, T right) => Create(left.Quantity * right);
+	public static Distance<T> operator *(T left, Distance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Distance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Distance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Distance<T> operator *(T left, Distance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Distance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Distance<T> operator /(Distance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Distance<T> operator /(Distance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Distance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 9974b9c..7dd178e 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Drag{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Drag{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Drag<T> operator -(Drag<T> value) => Create(-value.Quantity);
+	public static Drag<T> operator *(Drag<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Drag{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Drag{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Drag<T> operator *(Drag<T> left, T right) => Create(left.Quantity * right);
+	public static Drag<T> operator *(T left, Drag<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Drag{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Drag{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Drag<T> operator *(T left, Drag<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Drag{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Drag<T> operator /(Drag<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Drag<T> operator /(Drag<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Drag{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs
index 64ed9ec..b0e5096 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Duration.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Duration<T> operator +(Duration<T> left, Duration<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Duration{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Duration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator -(Duration<T> value) => Create(-value.Quantity);
+	public static Duration<T> operator *(Duration<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Duration{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Duration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator *(Duration<T> left, T right) => Create(left.Quantity * right);
+	public static Duration<T> operator *(T left, Duration<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Duration{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Duration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator *(T left, Duration<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Duration{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Duration<T> operator /(Duration<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Duration<T> operator /(Duration<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Duration{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 cf2de8b..5767532 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static DynamicViscosity<T> operator +(DynamicViscosity<T> left, DynamicViscosity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="DynamicViscosity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="DynamicViscosity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DynamicViscosity<T> operator -(DynamicViscosity<T> value) => Create(-value.Quantity);
+	public static DynamicViscosity<T> operator *(DynamicViscosity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="DynamicViscosity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="DynamicViscosity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DynamicViscosity<T> operator *(DynamicViscosity<T> left, T right) => Create(left.Quantity * right);
+	public static DynamicViscosity<T> operator *(T left, DynamicViscosity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="DynamicViscosity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="DynamicViscosity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DynamicViscosity<T> operator *(T left, DynamicViscosity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="DynamicViscosity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static DynamicViscosity<T> operator /(DynamicViscosity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static DynamicViscosity<T> operator /(DynamicViscosity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="DynamicViscosity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 41f9764..e8e2a2a 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="EMF{T}"/>.</summary>
+	/// <summary>Scales a <see cref="EMF{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EMF<T> operator -(EMF<T> value) => Create(-value.Quantity);
+	public static EMF<T> operator *(EMF<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="EMF{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="EMF{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EMF<T> operator *(EMF<T> left, T right) => Create(left.Quantity * right);
+	public static EMF<T> operator *(T left, EMF<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="EMF{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="EMF{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EMF<T> operator *(T left, EMF<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="EMF{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EMF<T> operator /(EMF<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static EMF<T> operator /(EMF<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="EMF{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs
index 418efd1..113f873 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricConductivity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ElectricConductivity<T> operator +(ElectricConductivity<T> left, ElectricConductivity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ElectricConductivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ElectricConductivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricConductivity<T> operator -(ElectricConductivity<T> value) => Create(-value.Quantity);
+	public static ElectricConductivity<T> operator *(ElectricConductivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ElectricConductivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ElectricConductivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricConductivity<T> operator *(ElectricConductivity<T> left, T right) => Create(left.Quantity * right);
+	public static ElectricConductivity<T> operator *(T left, ElectricConductivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ElectricConductivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ElectricConductivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricConductivity<T> operator *(T left, ElectricConductivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ElectricConductivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricConductivity<T> operator /(ElectricConductivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ElectricConductivity<T> operator /(ElectricConductivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ElectricConductivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs
index 67c97e3..0781db9 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricFieldMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ElectricFieldMagnitude<T> operator +(ElectricFieldMagnitude<T> left, ElectricFieldMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ElectricFieldMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ElectricFieldMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFieldMagnitude<T> operator -(ElectricFieldMagnitude<T> value) => Create(-value.Quantity);
+	public static ElectricFieldMagnitude<T> operator *(ElectricFieldMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ElectricFieldMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ElectricFieldMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFieldMagnitude<T> operator *(ElectricFieldMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static ElectricFieldMagnitude<T> operator *(T left, ElectricFieldMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ElectricFieldMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ElectricFieldMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFieldMagnitude<T> operator *(T left, ElectricFieldMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ElectricFieldMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFieldMagnitude<T> operator /(ElectricFieldMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ElectricFieldMagnitude<T> operator /(ElectricFieldMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ElectricFieldMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 10ce7ad..2a0a769 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ElectricFlux<T> operator +(ElectricFlux<T> left, ElectricFlux<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ElectricFlux{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ElectricFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFlux<T> operator -(ElectricFlux<T> value) => Create(-value.Quantity);
+	public static ElectricFlux<T> operator *(ElectricFlux<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ElectricFlux{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ElectricFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFlux<T> operator *(ElectricFlux<T> left, T right) => Create(left.Quantity * right);
+	public static ElectricFlux<T> operator *(T left, ElectricFlux<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ElectricFlux{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ElectricFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFlux<T> operator *(T left, ElectricFlux<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ElectricFlux{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricFlux<T> operator /(ElectricFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ElectricFlux<T> operator /(ElectricFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ElectricFlux{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs
index fc87f0b..0844fc3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ElectricPowerDensity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ElectricPowerDensity<T> operator +(ElectricPowerDensity<T> left, ElectricPowerDensity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ElectricPowerDensity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ElectricPowerDensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricPowerDensity<T> operator -(ElectricPowerDensity<T> value) => Create(-value.Quantity);
+	public static ElectricPowerDensity<T> operator *(ElectricPowerDensity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ElectricPowerDensity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ElectricPowerDensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricPowerDensity<T> operator *(ElectricPowerDensity<T> left, T right) => Create(left.Quantity * right);
+	public static ElectricPowerDensity<T> operator *(T left, ElectricPowerDensity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ElectricPowerDensity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ElectricPowerDensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricPowerDensity<T> operator *(T left, ElectricPowerDensity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ElectricPowerDensity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ElectricPowerDensity<T> operator /(ElectricPowerDensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ElectricPowerDensity<T> operator /(ElectricPowerDensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ElectricPowerDensity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 a8a5068..582e8e5 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Energy<T> operator +(Energy<T> left, Energy<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Energy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Energy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Energy<T> operator -(Energy<T> value) => Create(-value.Quantity);
+	public static Energy<T> operator *(Energy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Energy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Energy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Energy<T> operator *(Energy<T> left, T right) => Create(left.Quantity * right);
+	public static Energy<T> operator *(T left, Energy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Energy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Energy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Energy<T> operator *(T left, Energy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Energy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Energy<T> operator /(Energy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Energy<T> operator /(Energy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Energy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 18bb1d7..84643bc 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="EnergyFluxDensity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="EnergyFluxDensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnergyFluxDensity<T> operator -(EnergyFluxDensity<T> value) => Create(-value.Quantity);
+	public static EnergyFluxDensity<T> operator *(EnergyFluxDensity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="EnergyFluxDensity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="EnergyFluxDensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnergyFluxDensity<T> operator *(EnergyFluxDensity<T> left, T right) => Create(left.Quantity * right);
+	public static EnergyFluxDensity<T> operator *(T left, EnergyFluxDensity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="EnergyFluxDensity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="EnergyFluxDensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnergyFluxDensity<T> operator *(T left, EnergyFluxDensity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="EnergyFluxDensity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnergyFluxDensity<T> operator /(EnergyFluxDensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static EnergyFluxDensity<T> operator /(EnergyFluxDensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="EnergyFluxDensity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 6007a87..8ad959d 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Entropy<T> operator +(Entropy<T> left, Entropy<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Entropy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Entropy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Entropy<T> operator -(Entropy<T> value) => Create(-value.Quantity);
+	public static Entropy<T> operator *(Entropy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Entropy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Entropy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Entropy<T> operator *(Entropy<T> left, T right) => Create(left.Quantity * right);
+	public static Entropy<T> operator *(T left, Entropy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Entropy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Entropy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Entropy<T> operator *(T left, Entropy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Entropy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Entropy<T> operator /(Entropy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Entropy<T> operator /(Entropy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Entropy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 ba136da..fe485d3 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="EnzymeActivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="EnzymeActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnzymeActivity<T> operator -(EnzymeActivity<T> value) => Create(-value.Quantity);
+	public static EnzymeActivity<T> operator *(EnzymeActivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="EnzymeActivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="EnzymeActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnzymeActivity<T> operator *(EnzymeActivity<T> left, T right) => Create(left.Quantity * right);
+	public static EnzymeActivity<T> operator *(T left, EnzymeActivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="EnzymeActivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="EnzymeActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnzymeActivity<T> operator *(T left, EnzymeActivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="EnzymeActivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EnzymeActivity<T> operator /(EnzymeActivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static EnzymeActivity<T> operator /(EnzymeActivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="EnzymeActivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs
index ccc5217..ae16b06 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/EquivalentDose.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static EquivalentDose<T> operator +(EquivalentDose<T> left, EquivalentDose<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="EquivalentDose{T}"/>.</summary>
+	/// <summary>Scales a <see cref="EquivalentDose{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EquivalentDose<T> operator -(EquivalentDose<T> value) => Create(-value.Quantity);
+	public static EquivalentDose<T> operator *(EquivalentDose<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="EquivalentDose{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="EquivalentDose{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EquivalentDose<T> operator *(EquivalentDose<T> left, T right) => Create(left.Quantity * right);
+	public static EquivalentDose<T> operator *(T left, EquivalentDose<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="EquivalentDose{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="EquivalentDose{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EquivalentDose<T> operator *(T left, EquivalentDose<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="EquivalentDose{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static EquivalentDose<T> operator /(EquivalentDose<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static EquivalentDose<T> operator /(EquivalentDose<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="EquivalentDose{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs
index b8d83bc..639caa4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Exposure.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Exposure<T> operator +(Exposure<T> left, Exposure<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Exposure{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Exposure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Exposure<T> operator -(Exposure<T> value) => Create(-value.Quantity);
+	public static Exposure<T> operator *(Exposure<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Exposure{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Exposure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Exposure<T> operator *(Exposure<T> left, T right) => Create(left.Quantity * right);
+	public static Exposure<T> operator *(T left, Exposure<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Exposure{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Exposure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Exposure<T> operator *(T left, Exposure<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Exposure{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Exposure<T> operator /(Exposure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Exposure<T> operator /(Exposure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Exposure{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 7185c06..fa8435e 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="FieldOfView{T}"/>.</summary>
+	/// <summary>Scales a <see cref="FieldOfView{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FieldOfView<T> operator -(FieldOfView<T> value) => Create(-value.Quantity);
+	public static FieldOfView<T> operator *(FieldOfView<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="FieldOfView{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="FieldOfView{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FieldOfView<T> operator *(FieldOfView<T> left, T right) => Create(left.Quantity * right);
+	public static FieldOfView<T> operator *(T left, FieldOfView<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="FieldOfView{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="FieldOfView{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FieldOfView<T> operator *(T left, FieldOfView<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="FieldOfView{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FieldOfView<T> operator /(FieldOfView<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static FieldOfView<T> operator /(FieldOfView<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="FieldOfView{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 44a6869..c377864 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="FlowSpeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="FlowSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FlowSpeed<T> operator -(FlowSpeed<T> value) => Create(-value.Quantity);
+	public static FlowSpeed<T> operator *(FlowSpeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="FlowSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="FlowSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FlowSpeed<T> operator *(FlowSpeed<T> left, T right) => Create(left.Quantity * right);
+	public static FlowSpeed<T> operator *(T left, FlowSpeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="FlowSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="FlowSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FlowSpeed<T> operator *(T left, FlowSpeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="FlowSpeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static FlowSpeed<T> operator /(FlowSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static FlowSpeed<T> operator /(FlowSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="FlowSpeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5ba29a5..9f7f8c4 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ForceMagnitude<T> operator +(ForceMagnitude<T> left, ForceMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ForceMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ForceMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator -(ForceMagnitude<T> value) => Create(-value.Quantity);
+	public static ForceMagnitude<T> operator *(ForceMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ForceMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ForceMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator *(ForceMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static ForceMagnitude<T> operator *(T left, ForceMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ForceMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ForceMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator *(T left, ForceMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ForceMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ForceMagnitude<T> operator /(ForceMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ForceMagnitude<T> operator /(ForceMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ForceMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs
index 3e1eb9c..6305a2d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Frequency.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Frequency<T> operator +(Frequency<T> left, Frequency<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Frequency{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Frequency{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Frequency<T> operator -(Frequency<T> value) => Create(-value.Quantity);
+	public static Frequency<T> operator *(Frequency<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Frequency{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Frequency{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Frequency<T> operator *(Frequency<T> left, T right) => Create(left.Quantity * right);
+	public static Frequency<T> operator *(T left, Frequency<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Frequency{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Frequency{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Frequency<T> operator *(T left, Frequency<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Frequency{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Frequency<T> operator /(Frequency<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Frequency<T> operator /(Frequency<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Frequency{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 600ea70..fb04af6 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Friction{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Friction{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Friction<T> operator -(Friction<T> value) => Create(-value.Quantity);
+	public static Friction<T> operator *(Friction<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Friction{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Friction{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Friction<T> operator *(Friction<T> left, T right) => Create(left.Quantity * right);
+	public static Friction<T> operator *(T left, Friction<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Friction{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Friction{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Friction<T> operator *(T left, Friction<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Friction{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Friction<T> operator /(Friction<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Friction<T> operator /(Friction<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Friction{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 82218ac..d21d72a 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Gain{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Gain{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Gain<T> operator -(Gain<T> value) => Create(-value.Quantity);
+	public static Gain<T> operator *(Gain<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Gain{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Gain{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Gain<T> operator *(Gain<T> left, T right) => Create(left.Quantity * right);
+	public static Gain<T> operator *(T left, Gain<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Gain{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Gain{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Gain<T> operator *(T left, Gain<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Gain{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Gain<T> operator /(Gain<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Gain<T> operator /(Gain<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Gain{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 87c6c67..38b9b17 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="GaugePressure{T}"/>.</summary>
+	/// <summary>Scales a <see cref="GaugePressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GaugePressure<T> operator -(GaugePressure<T> value) => Create(-value.Quantity);
+	public static GaugePressure<T> operator *(GaugePressure<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="GaugePressure{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="GaugePressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GaugePressure<T> operator *(GaugePressure<T> left, T right) => Create(left.Quantity * right);
+	public static GaugePressure<T> operator *(T left, GaugePressure<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="GaugePressure{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="GaugePressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GaugePressure<T> operator *(T left, GaugePressure<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="GaugePressure{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GaugePressure<T> operator /(GaugePressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static GaugePressure<T> operator /(GaugePressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="GaugePressure{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 24fc0af..0e23edf 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="GravitationalAcceleration{T}"/>.</summary>
+	/// <summary>Scales a <see cref="GravitationalAcceleration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalAcceleration<T> operator -(GravitationalAcceleration<T> value) => Create(-value.Quantity);
+	public static GravitationalAcceleration<T> operator *(GravitationalAcceleration<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="GravitationalAcceleration{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="GravitationalAcceleration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalAcceleration<T> operator *(GravitationalAcceleration<T> left, T right) => Create(left.Quantity * right);
+	public static GravitationalAcceleration<T> operator *(T left, GravitationalAcceleration<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="GravitationalAcceleration{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="GravitationalAcceleration{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalAcceleration<T> operator *(T left, GravitationalAcceleration<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="GravitationalAcceleration{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalAcceleration<T> operator /(GravitationalAcceleration<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static GravitationalAcceleration<T> operator /(GravitationalAcceleration<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="GravitationalAcceleration{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 9030728..cf5d68e 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static GravitationalParameter<T> operator +(GravitationalParameter<T> left, GravitationalParameter<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="GravitationalParameter{T}"/>.</summary>
+	/// <summary>Scales a <see cref="GravitationalParameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalParameter<T> operator -(GravitationalParameter<T> value) => Create(-value.Quantity);
+	public static GravitationalParameter<T> operator *(GravitationalParameter<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="GravitationalParameter{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="GravitationalParameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalParameter<T> operator *(GravitationalParameter<T> left, T right) => Create(left.Quantity * right);
+	public static GravitationalParameter<T> operator *(T left, GravitationalParameter<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="GravitationalParameter{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="GravitationalParameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalParameter<T> operator *(T left, GravitationalParameter<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="GravitationalParameter{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GravitationalParameter<T> operator /(GravitationalParameter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static GravitationalParameter<T> operator /(GravitationalParameter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="GravitationalParameter{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 c5b18b6..e74a6c4 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="GroundSpeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="GroundSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroundSpeed<T> operator -(GroundSpeed<T> value) => Create(-value.Quantity);
+	public static GroundSpeed<T> operator *(GroundSpeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="GroundSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="GroundSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroundSpeed<T> operator *(GroundSpeed<T> left, T right) => Create(left.Quantity * right);
+	public static GroundSpeed<T> operator *(T left, GroundSpeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="GroundSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="GroundSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroundSpeed<T> operator *(T left, GroundSpeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="GroundSpeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroundSpeed<T> operator /(GroundSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static GroundSpeed<T> operator /(GroundSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="GroundSpeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 38846d8..985c2a1 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="GroupVelocity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="GroupVelocity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroupVelocity<T> operator -(GroupVelocity<T> value) => Create(-value.Quantity);
+	public static GroupVelocity<T> operator *(GroupVelocity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="GroupVelocity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="GroupVelocity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroupVelocity<T> operator *(GroupVelocity<T> left, T right) => Create(left.Quantity * right);
+	public static GroupVelocity<T> operator *(T left, GroupVelocity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="GroupVelocity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="GroupVelocity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroupVelocity<T> operator *(T left, GroupVelocity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="GroupVelocity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static GroupVelocity<T> operator /(GroupVelocity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static GroupVelocity<T> operator /(GroupVelocity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="GroupVelocity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 4562b12..06d4271 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,21 +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>Negates a <see cref="HalfLife{T}"/>.</summary>
+	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HalfLife<T> operator -(HalfLife<T> value) => Create(-value.Quantity);
+	public static HalfLife<T> operator *(HalfLife<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</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(left.Quantity * right);
+	public static HalfLife<T> operator *(T left, HalfLife<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="HalfLife{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="HalfLife{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</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(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="HalfLife{T}"/> by a bare number.</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(left.Quantity / right);
+	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)));
 
 	/// <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")]
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 b37f1e2..4089fa6 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Heat{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Heat{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Heat<T> operator -(Heat<T> value) => Create(-value.Quantity);
+	public static Heat<T> operator *(Heat<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Heat{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Heat{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Heat<T> operator *(Heat<T> left, T right) => Create(left.Quantity * right);
+	public static Heat<T> operator *(T left, Heat<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Heat{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Heat{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Heat<T> operator *(T left, Heat<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Heat{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Heat<T> operator /(Heat<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Heat<T> operator /(Heat<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Heat{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5414eea..0e2ddf0 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="HeatCapacity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="HeatCapacity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatCapacity<T> operator -(HeatCapacity<T> value) => Create(-value.Quantity);
+	public static HeatCapacity<T> operator *(HeatCapacity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="HeatCapacity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="HeatCapacity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatCapacity<T> operator *(HeatCapacity<T> left, T right) => Create(left.Quantity * right);
+	public static HeatCapacity<T> operator *(T left, HeatCapacity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="HeatCapacity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="HeatCapacity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatCapacity<T> operator *(T left, HeatCapacity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="HeatCapacity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatCapacity<T> operator /(HeatCapacity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static HeatCapacity<T> operator /(HeatCapacity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="HeatCapacity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 3d2b57f..a7686c8 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="HeatFlowRate{T}"/>.</summary>
+	/// <summary>Scales a <see cref="HeatFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlowRate<T> operator -(HeatFlowRate<T> value) => Create(-value.Quantity);
+	public static HeatFlowRate<T> operator *(HeatFlowRate<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="HeatFlowRate{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="HeatFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlowRate<T> operator *(HeatFlowRate<T> left, T right) => Create(left.Quantity * right);
+	public static HeatFlowRate<T> operator *(T left, HeatFlowRate<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="HeatFlowRate{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="HeatFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlowRate<T> operator *(T left, HeatFlowRate<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="HeatFlowRate{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlowRate<T> operator /(HeatFlowRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static HeatFlowRate<T> operator /(HeatFlowRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="HeatFlowRate{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 41c811e..13e91bc 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="HeatFlux{T}"/>.</summary>
+	/// <summary>Scales a <see cref="HeatFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlux<T> operator -(HeatFlux<T> value) => Create(-value.Quantity);
+	public static HeatFlux<T> operator *(HeatFlux<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="HeatFlux{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="HeatFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlux<T> operator *(HeatFlux<T> left, T right) => Create(left.Quantity * right);
+	public static HeatFlux<T> operator *(T left, HeatFlux<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="HeatFlux{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="HeatFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlux<T> operator *(T left, HeatFlux<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="HeatFlux{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatFlux<T> operator /(HeatFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static HeatFlux<T> operator /(HeatFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="HeatFlux{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs
index 8aed95f..f453f0e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HeatTransferCoefficient.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static HeatTransferCoefficient<T> operator +(HeatTransferCoefficient<T> left, HeatTransferCoefficient<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="HeatTransferCoefficient{T}"/>.</summary>
+	/// <summary>Scales a <see cref="HeatTransferCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatTransferCoefficient<T> operator -(HeatTransferCoefficient<T> value) => Create(-value.Quantity);
+	public static HeatTransferCoefficient<T> operator *(HeatTransferCoefficient<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="HeatTransferCoefficient{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="HeatTransferCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatTransferCoefficient<T> operator *(HeatTransferCoefficient<T> left, T right) => Create(left.Quantity * right);
+	public static HeatTransferCoefficient<T> operator *(T left, HeatTransferCoefficient<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="HeatTransferCoefficient{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="HeatTransferCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatTransferCoefficient<T> operator *(T left, HeatTransferCoefficient<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="HeatTransferCoefficient{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static HeatTransferCoefficient<T> operator /(HeatTransferCoefficient<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static HeatTransferCoefficient<T> operator /(HeatTransferCoefficient<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="HeatTransferCoefficient{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 2481055..8791452 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Height{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Height{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Height<T> operator -(Height<T> value) => Create(-value.Quantity);
+	public static Height<T> operator *(Height<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Height{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Height{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Height<T> operator *(Height<T> left, T right) => Create(left.Quantity * right);
+	public static Height<T> operator *(T left, Height<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Height{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Height{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Height<T> operator *(T left, Height<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Height{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Height<T> operator /(Height<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Height<T> operator /(Height<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Height{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs
index dc25f3e..ac9274c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Illuminance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Illuminance<T> operator +(Illuminance<T> left, Illuminance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Illuminance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Illuminance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Illuminance<T> operator -(Illuminance<T> value) => Create(-value.Quantity);
+	public static Illuminance<T> operator *(Illuminance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Illuminance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Illuminance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Illuminance<T> operator *(Illuminance<T> left, T right) => Create(left.Quantity * right);
+	public static Illuminance<T> operator *(T left, Illuminance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Illuminance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Illuminance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Illuminance<T> operator *(T left, Illuminance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Illuminance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Illuminance<T> operator /(Illuminance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Illuminance<T> operator /(Illuminance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Illuminance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 be29ecd..752715f 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Impedance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Impedance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Impedance<T> operator -(Impedance<T> value) => Create(-value.Quantity);
+	public static Impedance<T> operator *(Impedance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Impedance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Impedance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Impedance<T> operator *(Impedance<T> left, T right) => Create(left.Quantity * right);
+	public static Impedance<T> operator *(T left, Impedance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Impedance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Impedance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Impedance<T> operator *(T left, Impedance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Impedance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Impedance<T> operator /(Impedance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Impedance<T> operator /(Impedance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Impedance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs
index c67bbb1..84781a5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Inductance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Inductance<T> operator +(Inductance<T> left, Inductance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Inductance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Inductance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Inductance<T> operator -(Inductance<T> value) => Create(-value.Quantity);
+	public static Inductance<T> operator *(Inductance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Inductance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Inductance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Inductance<T> operator *(Inductance<T> left, T right) => Create(left.Quantity * right);
+	public static Inductance<T> operator *(T left, Inductance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Inductance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Inductance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Inductance<T> operator *(T left, Inductance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Inductance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Inductance<T> operator /(Inductance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Inductance<T> operator /(Inductance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Inductance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs
index 588a955..236aea5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Irradiance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Irradiance<T> operator +(Irradiance<T> left, Irradiance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Irradiance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Irradiance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Irradiance<T> operator -(Irradiance<T> value) => Create(-value.Quantity);
+	public static Irradiance<T> operator *(Irradiance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Irradiance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Irradiance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Irradiance<T> operator *(Irradiance<T> left, T right) => Create(left.Quantity * right);
+	public static Irradiance<T> operator *(T left, Irradiance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Irradiance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Irradiance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Irradiance<T> operator *(T left, Irradiance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Irradiance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Irradiance<T> operator /(Irradiance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Irradiance<T> operator /(Irradiance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Irradiance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 e1239d8..c2a936d 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static JerkMagnitude<T> operator +(JerkMagnitude<T> left, JerkMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="JerkMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="JerkMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static JerkMagnitude<T> operator -(JerkMagnitude<T> value) => Create(-value.Quantity);
+	public static JerkMagnitude<T> operator *(JerkMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="JerkMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="JerkMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static JerkMagnitude<T> operator *(JerkMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static JerkMagnitude<T> operator *(T left, JerkMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="JerkMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="JerkMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static JerkMagnitude<T> operator *(T left, JerkMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="JerkMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static JerkMagnitude<T> operator /(JerkMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static JerkMagnitude<T> operator /(JerkMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="JerkMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs
index 9c99f45..5a94c6f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/KinematicViscosity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static KinematicViscosity<T> operator +(KinematicViscosity<T> left, KinematicViscosity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="KinematicViscosity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="KinematicViscosity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KinematicViscosity<T> operator -(KinematicViscosity<T> value) => Create(-value.Quantity);
+	public static KinematicViscosity<T> operator *(KinematicViscosity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="KinematicViscosity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="KinematicViscosity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KinematicViscosity<T> operator *(KinematicViscosity<T> left, T right) => Create(left.Quantity * right);
+	public static KinematicViscosity<T> operator *(T left, KinematicViscosity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="KinematicViscosity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="KinematicViscosity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KinematicViscosity<T> operator *(T left, KinematicViscosity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="KinematicViscosity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KinematicViscosity<T> operator /(KinematicViscosity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static KinematicViscosity<T> operator /(KinematicViscosity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="KinematicViscosity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 9ba3b07..a6e06f8 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="KineticEnergy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="KineticEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KineticEnergy<T> operator -(KineticEnergy<T> value) => Create(-value.Quantity);
+	public static KineticEnergy<T> operator *(KineticEnergy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="KineticEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="KineticEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KineticEnergy<T> operator *(KineticEnergy<T> left, T right) => Create(left.Quantity * right);
+	public static KineticEnergy<T> operator *(T left, KineticEnergy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="KineticEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="KineticEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KineticEnergy<T> operator *(T left, KineticEnergy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="KineticEnergy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static KineticEnergy<T> operator /(KineticEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static KineticEnergy<T> operator /(KineticEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="KineticEnergy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 567d9b3..f5940e8 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Latency{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Latency{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Latency<T> operator -(Latency<T> value) => Create(-value.Quantity);
+	public static Latency<T> operator *(Latency<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Latency{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Latency{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Latency<T> operator *(Latency<T> left, T right) => Create(left.Quantity * right);
+	public static Latency<T> operator *(T left, Latency<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Latency{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Latency{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Latency<T> operator *(T left, Latency<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Latency{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Latency<T> operator /(Latency<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Latency<T> operator /(Latency<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Latency{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 d89396d..a55156d 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Length<T> operator +(Length<T> left, Length<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Length{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Length{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator -(Length<T> value) => Create(-value.Quantity);
+	public static Length<T> operator *(Length<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Length{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Length{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator *(Length<T> left, T right) => Create(left.Quantity * right);
+	public static Length<T> operator *(T left, Length<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Length{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Length{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator *(T left, Length<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Length{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Length<T> operator /(Length<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Length<T> operator /(Length<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Length{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 b555559..46aa4a3 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Lift{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Lift{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Lift<T> operator -(Lift<T> value) => Create(-value.Quantity);
+	public static Lift<T> operator *(Lift<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Lift{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Lift{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Lift<T> operator *(Lift<T> left, T right) => Create(left.Quantity * right);
+	public static Lift<T> operator *(T left, Lift<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Lift{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Lift{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Lift<T> operator *(T left, Lift<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Lift{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Lift<T> operator /(Lift<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Lift<T> operator /(Lift<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Lift{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs
index d6979d5..ae740fc 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Loudness.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Loudness<T> operator +(Loudness<T> left, Loudness<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Loudness{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Loudness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Loudness<T> operator -(Loudness<T> value) => Create(-value.Quantity);
+	public static Loudness<T> operator *(Loudness<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Loudness{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Loudness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Loudness<T> operator *(Loudness<T> left, T right) => Create(left.Quantity * right);
+	public static Loudness<T> operator *(T left, Loudness<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Loudness{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Loudness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Loudness<T> operator *(T left, Loudness<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Loudness{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Loudness<T> operator /(Loudness<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Loudness<T> operator /(Loudness<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Loudness{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs
index 1eb153e..7bc09d4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Luminance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Luminance<T> operator +(Luminance<T> left, Luminance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Luminance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Luminance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Luminance<T> operator -(Luminance<T> value) => Create(-value.Quantity);
+	public static Luminance<T> operator *(Luminance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Luminance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Luminance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Luminance<T> operator *(Luminance<T> left, T right) => Create(left.Quantity * right);
+	public static Luminance<T> operator *(T left, Luminance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Luminance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Luminance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Luminance<T> operator *(T left, Luminance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Luminance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Luminance<T> operator /(Luminance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Luminance<T> operator /(Luminance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Luminance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 8ca42f4..dfb0f29 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static LuminousFlux<T> operator +(LuminousFlux<T> left, LuminousFlux<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="LuminousFlux{T}"/>.</summary>
+	/// <summary>Scales a <see cref="LuminousFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousFlux<T> operator -(LuminousFlux<T> value) => Create(-value.Quantity);
+	public static LuminousFlux<T> operator *(LuminousFlux<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="LuminousFlux{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="LuminousFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousFlux<T> operator *(LuminousFlux<T> left, T right) => Create(left.Quantity * right);
+	public static LuminousFlux<T> operator *(T left, LuminousFlux<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="LuminousFlux{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="LuminousFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousFlux<T> operator *(T left, LuminousFlux<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="LuminousFlux{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousFlux<T> operator /(LuminousFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static LuminousFlux<T> operator /(LuminousFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="LuminousFlux{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 54a0022..302ca4a 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static LuminousIntensity<T> operator +(LuminousIntensity<T> left, LuminousIntensity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="LuminousIntensity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="LuminousIntensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousIntensity<T> operator -(LuminousIntensity<T> value) => Create(-value.Quantity);
+	public static LuminousIntensity<T> operator *(LuminousIntensity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="LuminousIntensity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="LuminousIntensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousIntensity<T> operator *(LuminousIntensity<T> left, T right) => Create(left.Quantity * right);
+	public static LuminousIntensity<T> operator *(T left, LuminousIntensity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="LuminousIntensity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="LuminousIntensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousIntensity<T> operator *(T left, LuminousIntensity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="LuminousIntensity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static LuminousIntensity<T> operator /(LuminousIntensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static LuminousIntensity<T> operator /(LuminousIntensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="LuminousIntensity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 82cb3d8..8e4f539 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MachNumber{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MachNumber{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MachNumber<T> operator -(MachNumber<T> value) => Create(-value.Quantity);
+	public static MachNumber<T> operator *(MachNumber<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MachNumber{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MachNumber{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MachNumber<T> operator *(MachNumber<T> left, T right) => Create(left.Quantity * right);
+	public static MachNumber<T> operator *(T left, MachNumber<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MachNumber{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MachNumber{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MachNumber<T> operator *(T left, MachNumber<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MachNumber{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MachNumber<T> operator /(MachNumber<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MachNumber<T> operator /(MachNumber<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MachNumber{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 3b7db79..41f2dc6 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MagneticFlux<T> operator +(MagneticFlux<T> left, MagneticFlux<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MagneticFlux{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MagneticFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFlux<T> operator -(MagneticFlux<T> value) => Create(-value.Quantity);
+	public static MagneticFlux<T> operator *(MagneticFlux<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MagneticFlux{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MagneticFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFlux<T> operator *(MagneticFlux<T> left, T right) => Create(left.Quantity * right);
+	public static MagneticFlux<T> operator *(T left, MagneticFlux<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MagneticFlux{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MagneticFlux{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFlux<T> operator *(T left, MagneticFlux<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MagneticFlux{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFlux<T> operator /(MagneticFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MagneticFlux<T> operator /(MagneticFlux<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MagneticFlux{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs
index 36a85ef..25bce0c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MagneticFluxDensityMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MagneticFluxDensityMagnitude<T> operator +(MagneticFluxDensityMagnitude<T> left, MagneticFluxDensityMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MagneticFluxDensityMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MagneticFluxDensityMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFluxDensityMagnitude<T> operator -(MagneticFluxDensityMagnitude<T> value) => Create(-value.Quantity);
+	public static MagneticFluxDensityMagnitude<T> operator *(MagneticFluxDensityMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MagneticFluxDensityMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MagneticFluxDensityMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFluxDensityMagnitude<T> operator *(MagneticFluxDensityMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static MagneticFluxDensityMagnitude<T> operator *(T left, MagneticFluxDensityMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MagneticFluxDensityMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MagneticFluxDensityMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFluxDensityMagnitude<T> operator *(T left, MagneticFluxDensityMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MagneticFluxDensityMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MagneticFluxDensityMagnitude<T> operator /(MagneticFluxDensityMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MagneticFluxDensityMagnitude<T> operator /(MagneticFluxDensityMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MagneticFluxDensityMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 bf48132..d002777 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Mass<T> operator +(Mass<T> left, Mass<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Mass{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Mass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator -(Mass<T> value) => Create(-value.Quantity);
+	public static Mass<T> operator *(Mass<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Mass{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Mass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator *(Mass<T> left, T right) => Create(left.Quantity * right);
+	public static Mass<T> operator *(T left, Mass<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Mass{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Mass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator *(T left, Mass<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Mass{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Mass<T> operator /(Mass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Mass<T> operator /(Mass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Mass{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs
index 5228eed..b663bf2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MassFlowRate.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MassFlowRate<T> operator +(MassFlowRate<T> left, MassFlowRate<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MassFlowRate{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MassFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MassFlowRate<T> operator -(MassFlowRate<T> value) => Create(-value.Quantity);
+	public static MassFlowRate<T> operator *(MassFlowRate<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MassFlowRate{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MassFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MassFlowRate<T> operator *(MassFlowRate<T> left, T right) => Create(left.Quantity * right);
+	public static MassFlowRate<T> operator *(T left, MassFlowRate<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MassFlowRate{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MassFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MassFlowRate<T> operator *(T left, MassFlowRate<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MassFlowRate{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MassFlowRate<T> operator /(MassFlowRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MassFlowRate<T> operator /(MassFlowRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MassFlowRate{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs
index 04cc658..1b642e5 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarEnergy.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MolarEnergy<T> operator +(MolarEnergy<T> left, MolarEnergy<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MolarEnergy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MolarEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnergy<T> operator -(MolarEnergy<T> value) => Create(-value.Quantity);
+	public static MolarEnergy<T> operator *(MolarEnergy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MolarEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MolarEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnergy<T> operator *(MolarEnergy<T> left, T right) => Create(left.Quantity * right);
+	public static MolarEnergy<T> operator *(T left, MolarEnergy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MolarEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MolarEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnergy<T> operator *(T left, MolarEnergy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MolarEnergy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnergy<T> operator /(MolarEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MolarEnergy<T> operator /(MolarEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MolarEnergy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 164eb57..babe0b5 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MolarEnthalpy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MolarEnthalpy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnthalpy<T> operator -(MolarEnthalpy<T> value) => Create(-value.Quantity);
+	public static MolarEnthalpy<T> operator *(MolarEnthalpy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MolarEnthalpy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MolarEnthalpy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnthalpy<T> operator *(MolarEnthalpy<T> left, T right) => Create(left.Quantity * right);
+	public static MolarEnthalpy<T> operator *(T left, MolarEnthalpy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MolarEnthalpy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MolarEnthalpy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnthalpy<T> operator *(T left, MolarEnthalpy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MolarEnthalpy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarEnthalpy<T> operator /(MolarEnthalpy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MolarEnthalpy<T> operator /(MolarEnthalpy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MolarEnthalpy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs
index bcc3c83..6c50c31 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MolarMass.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MolarMass<T> operator +(MolarMass<T> left, MolarMass<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MolarMass{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MolarMass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarMass<T> operator -(MolarMass<T> value) => Create(-value.Quantity);
+	public static MolarMass<T> operator *(MolarMass<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MolarMass{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MolarMass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarMass<T> operator *(MolarMass<T> left, T right) => Create(left.Quantity * right);
+	public static MolarMass<T> operator *(T left, MolarMass<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MolarMass{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MolarMass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarMass<T> operator *(T left, MolarMass<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MolarMass{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MolarMass<T> operator /(MolarMass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MolarMass<T> operator /(MolarMass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MolarMass{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs
index 604c4b3..b034946 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/MomentOfInertia.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MomentOfInertia<T> operator +(MomentOfInertia<T> left, MomentOfInertia<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MomentOfInertia{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MomentOfInertia{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentOfInertia<T> operator -(MomentOfInertia<T> value) => Create(-value.Quantity);
+	public static MomentOfInertia<T> operator *(MomentOfInertia<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MomentOfInertia{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MomentOfInertia{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentOfInertia<T> operator *(MomentOfInertia<T> left, T right) => Create(left.Quantity * right);
+	public static MomentOfInertia<T> operator *(T left, MomentOfInertia<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MomentOfInertia{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MomentOfInertia{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentOfInertia<T> operator *(T left, MomentOfInertia<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MomentOfInertia{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentOfInertia<T> operator /(MomentOfInertia<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MomentOfInertia<T> operator /(MomentOfInertia<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MomentOfInertia{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 f39c5ab..21a8eee 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static MomentumMagnitude<T> operator +(MomentumMagnitude<T> left, MomentumMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="MomentumMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="MomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentumMagnitude<T> operator -(MomentumMagnitude<T> value) => Create(-value.Quantity);
+	public static MomentumMagnitude<T> operator *(MomentumMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="MomentumMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="MomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentumMagnitude<T> operator *(MomentumMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static MomentumMagnitude<T> operator *(T left, MomentumMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="MomentumMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="MomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentumMagnitude<T> operator *(T left, MomentumMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="MomentumMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static MomentumMagnitude<T> operator /(MomentumMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static MomentumMagnitude<T> operator /(MomentumMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="MomentumMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 1ac146f..125829f 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="NoiseReductionCoefficient{T}"/>.</summary>
+	/// <summary>Scales a <see cref="NoiseReductionCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NoiseReductionCoefficient<T> operator -(NoiseReductionCoefficient<T> value) => Create(-value.Quantity);
+	public static NoiseReductionCoefficient<T> operator *(NoiseReductionCoefficient<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="NoiseReductionCoefficient{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="NoiseReductionCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NoiseReductionCoefficient<T> operator *(NoiseReductionCoefficient<T> left, T right) => Create(left.Quantity * right);
+	public static NoiseReductionCoefficient<T> operator *(T left, NoiseReductionCoefficient<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="NoiseReductionCoefficient{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="NoiseReductionCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NoiseReductionCoefficient<T> operator *(T left, NoiseReductionCoefficient<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="NoiseReductionCoefficient{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NoiseReductionCoefficient<T> operator /(NoiseReductionCoefficient<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static NoiseReductionCoefficient<T> operator /(NoiseReductionCoefficient<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="NoiseReductionCoefficient{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5ddc7c2..8de8ed8 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="NormalForce{T}"/>.</summary>
+	/// <summary>Scales a <see cref="NormalForce{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NormalForce<T> operator -(NormalForce<T> value) => Create(-value.Quantity);
+	public static NormalForce<T> operator *(NormalForce<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="NormalForce{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="NormalForce{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NormalForce<T> operator *(NormalForce<T> left, T right) => Create(left.Quantity * right);
+	public static NormalForce<T> operator *(T left, NormalForce<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="NormalForce{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="NormalForce{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NormalForce<T> operator *(T left, NormalForce<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="NormalForce{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NormalForce<T> operator /(NormalForce<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static NormalForce<T> operator /(NormalForce<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="NormalForce{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs
index 6438f27..e1babab 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/NuclearCrossSection.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static NuclearCrossSection<T> operator +(NuclearCrossSection<T> left, NuclearCrossSection<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="NuclearCrossSection{T}"/>.</summary>
+	/// <summary>Scales a <see cref="NuclearCrossSection{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NuclearCrossSection<T> operator -(NuclearCrossSection<T> value) => Create(-value.Quantity);
+	public static NuclearCrossSection<T> operator *(NuclearCrossSection<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="NuclearCrossSection{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="NuclearCrossSection{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NuclearCrossSection<T> operator *(NuclearCrossSection<T> left, T right) => Create(left.Quantity * right);
+	public static NuclearCrossSection<T> operator *(T left, NuclearCrossSection<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="NuclearCrossSection{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="NuclearCrossSection{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NuclearCrossSection<T> operator *(T left, NuclearCrossSection<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="NuclearCrossSection{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static NuclearCrossSection<T> operator /(NuclearCrossSection<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static NuclearCrossSection<T> operator /(NuclearCrossSection<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="NuclearCrossSection{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs
index f4cf849..1773bee 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/OpticalPower.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static OpticalPower<T> operator +(OpticalPower<T> left, OpticalPower<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="OpticalPower{T}"/>.</summary>
+	/// <summary>Scales a <see cref="OpticalPower{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static OpticalPower<T> operator -(OpticalPower<T> value) => Create(-value.Quantity);
+	public static OpticalPower<T> operator *(OpticalPower<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="OpticalPower{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="OpticalPower{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static OpticalPower<T> operator *(OpticalPower<T> left, T right) => Create(left.Quantity * right);
+	public static OpticalPower<T> operator *(T left, OpticalPower<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="OpticalPower{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="OpticalPower{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static OpticalPower<T> operator *(T left, OpticalPower<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="OpticalPower{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static OpticalPower<T> operator /(OpticalPower<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static OpticalPower<T> operator /(OpticalPower<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="OpticalPower{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 b5c6a33..0966914 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Perimeter{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Perimeter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Perimeter<T> operator -(Perimeter<T> value) => Create(-value.Quantity);
+	public static Perimeter<T> operator *(Perimeter<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Perimeter{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Perimeter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Perimeter<T> operator *(Perimeter<T> left, T right) => Create(left.Quantity * right);
+	public static Perimeter<T> operator *(T left, Perimeter<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Perimeter{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Perimeter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Perimeter<T> operator *(T left, Perimeter<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Perimeter{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Perimeter<T> operator /(Perimeter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Perimeter<T> operator /(Perimeter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Perimeter{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 71dc967..036d922 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,21 +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>Negates a <see cref="Period{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Period<T> operator -(Period<T> value) => Create(-value.Quantity);
+	public static Period<T> operator *(Period<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Period{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</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(left.Quantity * right);
+	public static Period<T> operator *(T left, Period<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Period{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Period{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</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(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Period{T}"/> by a bare number.</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(left.Quantity / right);
+	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)));
 
 	/// <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")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs
index 77e29f0..9fcc0d4 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Permittivity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Permittivity<T> operator +(Permittivity<T> left, Permittivity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Permittivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Permittivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Permittivity<T> operator -(Permittivity<T> value) => Create(-value.Quantity);
+	public static Permittivity<T> operator *(Permittivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Permittivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Permittivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Permittivity<T> operator *(Permittivity<T> left, T right) => Create(left.Quantity * right);
+	public static Permittivity<T> operator *(T left, Permittivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Permittivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Permittivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Permittivity<T> operator *(T left, Permittivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Permittivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Permittivity<T> operator /(Permittivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Permittivity<T> operator /(Permittivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Permittivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 beb534c..cb80677 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="PhaseVelocity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="PhaseVelocity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PhaseVelocity<T> operator -(PhaseVelocity<T> value) => Create(-value.Quantity);
+	public static PhaseVelocity<T> operator *(PhaseVelocity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="PhaseVelocity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="PhaseVelocity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PhaseVelocity<T> operator *(PhaseVelocity<T> left, T right) => Create(left.Quantity * right);
+	public static PhaseVelocity<T> operator *(T left, PhaseVelocity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="PhaseVelocity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="PhaseVelocity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PhaseVelocity<T> operator *(T left, PhaseVelocity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="PhaseVelocity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PhaseVelocity<T> operator /(PhaseVelocity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static PhaseVelocity<T> operator /(PhaseVelocity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="PhaseVelocity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 7764e0d..4ccf93d 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Pitch{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Pitch{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pitch<T> operator -(Pitch<T> value) => Create(-value.Quantity);
+	public static Pitch<T> operator *(Pitch<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Pitch{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Pitch{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pitch<T> operator *(Pitch<T> left, T right) => Create(left.Quantity * right);
+	public static Pitch<T> operator *(T left, Pitch<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Pitch{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Pitch{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pitch<T> operator *(T left, Pitch<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Pitch{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pitch<T> operator /(Pitch<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Pitch<T> operator /(Pitch<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Pitch{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 2053be3..6027bbb 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="PotentialEnergy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="PotentialEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PotentialEnergy<T> operator -(PotentialEnergy<T> value) => Create(-value.Quantity);
+	public static PotentialEnergy<T> operator *(PotentialEnergy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="PotentialEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="PotentialEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PotentialEnergy<T> operator *(PotentialEnergy<T> left, T right) => Create(left.Quantity * right);
+	public static PotentialEnergy<T> operator *(T left, PotentialEnergy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="PotentialEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="PotentialEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PotentialEnergy<T> operator *(T left, PotentialEnergy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="PotentialEnergy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static PotentialEnergy<T> operator /(PotentialEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static PotentialEnergy<T> operator /(PotentialEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="PotentialEnergy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 03edb64..e36096d 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Power<T> operator +(Power<T> left, Power<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Power{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Power{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Power<T> operator -(Power<T> value) => Create(-value.Quantity);
+	public static Power<T> operator *(Power<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Power{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Power{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Power<T> operator *(Power<T> left, T right) => Create(left.Quantity * right);
+	public static Power<T> operator *(T left, Power<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Power{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Power{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Power<T> operator *(T left, Power<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Power{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Power<T> operator /(Power<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Power<T> operator /(Power<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Power{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs
index 47b6ae1..c94319e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Pressure.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Pressure<T> operator +(Pressure<T> left, Pressure<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Pressure{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Pressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator -(Pressure<T> value) => Create(-value.Quantity);
+	public static Pressure<T> operator *(Pressure<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Pressure{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Pressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator *(Pressure<T> left, T right) => Create(left.Quantity * right);
+	public static Pressure<T> operator *(T left, Pressure<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Pressure{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Pressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator *(T left, Pressure<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Pressure{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Pressure<T> operator /(Pressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Pressure<T> operator /(Pressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Pressure{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs
index 10d79ee..697e8ad 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RadioactiveActivity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static RadioactiveActivity<T> operator +(RadioactiveActivity<T> left, RadioactiveActivity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="RadioactiveActivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="RadioactiveActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RadioactiveActivity<T> operator -(RadioactiveActivity<T> value) => Create(-value.Quantity);
+	public static RadioactiveActivity<T> operator *(RadioactiveActivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="RadioactiveActivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="RadioactiveActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RadioactiveActivity<T> operator *(RadioactiveActivity<T> left, T right) => Create(left.Quantity * right);
+	public static RadioactiveActivity<T> operator *(T left, RadioactiveActivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="RadioactiveActivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="RadioactiveActivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RadioactiveActivity<T> operator *(T left, RadioactiveActivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="RadioactiveActivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RadioactiveActivity<T> operator /(RadioactiveActivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static RadioactiveActivity<T> operator /(RadioactiveActivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="RadioactiveActivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 02f5674..9fb9336 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Radius{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Radius{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Radius<T> operator -(Radius<T> value) => Create(-value.Quantity);
+	public static Radius<T> operator *(Radius<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Radius{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Radius{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Radius<T> operator *(Radius<T> left, T right) => Create(left.Quantity * right);
+	public static Radius<T> operator *(T left, Radius<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Radius{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Radius{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Radius<T> operator *(T left, Radius<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Radius{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Radius<T> operator /(Radius<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Radius<T> operator /(Radius<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Radius{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs
index 8ebc506..b910b8c 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/RateConstant.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static RateConstant<T> operator +(RateConstant<T> left, RateConstant<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="RateConstant{T}"/>.</summary>
+	/// <summary>Scales a <see cref="RateConstant{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RateConstant<T> operator -(RateConstant<T> value) => Create(-value.Quantity);
+	public static RateConstant<T> operator *(RateConstant<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="RateConstant{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="RateConstant{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RateConstant<T> operator *(RateConstant<T> left, T right) => Create(left.Quantity * right);
+	public static RateConstant<T> operator *(T left, RateConstant<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="RateConstant{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="RateConstant{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RateConstant<T> operator *(T left, RateConstant<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="RateConstant{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RateConstant<T> operator /(RateConstant<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static RateConstant<T> operator /(RateConstant<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="RateConstant{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 f9e86cc..ab24c2e 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Ratio<T> operator +(Ratio<T> left, Ratio<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Ratio{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Ratio{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Ratio<T> operator -(Ratio<T> value) => Create(-value.Quantity);
+	public static Ratio<T> operator *(Ratio<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Ratio{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Ratio{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Ratio<T> operator *(Ratio<T> left, T right) => Create(left.Quantity * right);
+	public static Ratio<T> operator *(T left, Ratio<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Ratio{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Ratio{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Ratio<T> operator *(T left, Ratio<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Ratio{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Ratio<T> operator /(Ratio<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Ratio<T> operator /(Ratio<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Ratio{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs
index fb42734..7fe96a0 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ReactionRate.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ReactionRate<T> operator +(ReactionRate<T> left, ReactionRate<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ReactionRate{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ReactionRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReactionRate<T> operator -(ReactionRate<T> value) => Create(-value.Quantity);
+	public static ReactionRate<T> operator *(ReactionRate<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ReactionRate{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ReactionRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReactionRate<T> operator *(ReactionRate<T> left, T right) => Create(left.Quantity * right);
+	public static ReactionRate<T> operator *(T left, ReactionRate<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ReactionRate{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ReactionRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReactionRate<T> operator *(T left, ReactionRate<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ReactionRate{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReactionRate<T> operator /(ReactionRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ReactionRate<T> operator /(ReactionRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ReactionRate{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 736e241..56af640 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="RefractiveIndex{T}"/>.</summary>
+	/// <summary>Scales a <see cref="RefractiveIndex{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RefractiveIndex<T> operator -(RefractiveIndex<T> value) => Create(-value.Quantity);
+	public static RefractiveIndex<T> operator *(RefractiveIndex<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="RefractiveIndex{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="RefractiveIndex{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RefractiveIndex<T> operator *(RefractiveIndex<T> left, T right) => Create(left.Quantity * right);
+	public static RefractiveIndex<T> operator *(T left, RefractiveIndex<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="RefractiveIndex{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="RefractiveIndex{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RefractiveIndex<T> operator *(T left, RefractiveIndex<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="RefractiveIndex{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static RefractiveIndex<T> operator /(RefractiveIndex<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static RefractiveIndex<T> operator /(RefractiveIndex<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="RefractiveIndex{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs
index 80b9974..8e7b49e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Resistance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Resistance<T> operator +(Resistance<T> left, Resistance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Resistance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Resistance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Resistance<T> operator -(Resistance<T> value) => Create(-value.Quantity);
+	public static Resistance<T> operator *(Resistance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Resistance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Resistance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Resistance<T> operator *(Resistance<T> left, T right) => Create(left.Quantity * right);
+	public static Resistance<T> operator *(T left, Resistance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Resistance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Resistance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Resistance<T> operator *(T left, Resistance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Resistance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Resistance<T> operator /(Resistance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Resistance<T> operator /(Resistance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Resistance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5199c1b..df76f8b 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ReverberationTime{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ReverberationTime{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReverberationTime<T> operator -(ReverberationTime<T> value) => Create(-value.Quantity);
+	public static ReverberationTime<T> operator *(ReverberationTime<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ReverberationTime{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ReverberationTime{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReverberationTime<T> operator *(ReverberationTime<T> left, T right) => Create(left.Quantity * right);
+	public static ReverberationTime<T> operator *(T left, ReverberationTime<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ReverberationTime{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ReverberationTime{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReverberationTime<T> operator *(T left, ReverberationTime<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ReverberationTime{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReverberationTime<T> operator /(ReverberationTime<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ReverberationTime<T> operator /(ReverberationTime<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ReverberationTime{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 0303e50..0243ff1 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ReynoldsNumber{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ReynoldsNumber{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReynoldsNumber<T> operator -(ReynoldsNumber<T> value) => Create(-value.Quantity);
+	public static ReynoldsNumber<T> operator *(ReynoldsNumber<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ReynoldsNumber{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ReynoldsNumber{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReynoldsNumber<T> operator *(ReynoldsNumber<T> left, T right) => Create(left.Quantity * right);
+	public static ReynoldsNumber<T> operator *(T left, ReynoldsNumber<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ReynoldsNumber{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ReynoldsNumber{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReynoldsNumber<T> operator *(T left, ReynoldsNumber<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ReynoldsNumber{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ReynoldsNumber<T> operator /(ReynoldsNumber<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ReynoldsNumber<T> operator /(ReynoldsNumber<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ReynoldsNumber{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 5bd7774..579d505 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SamplingRate{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SamplingRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SamplingRate<T> operator -(SamplingRate<T> value) => Create(-value.Quantity);
+	public static SamplingRate<T> operator *(SamplingRate<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SamplingRate{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SamplingRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SamplingRate<T> operator *(SamplingRate<T> left, T right) => Create(left.Quantity * right);
+	public static SamplingRate<T> operator *(T left, SamplingRate<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SamplingRate{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SamplingRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SamplingRate<T> operator *(T left, SamplingRate<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SamplingRate{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SamplingRate<T> operator /(SamplingRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SamplingRate<T> operator /(SamplingRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SamplingRate{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs
index 2039d2a..49add2f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sensitivity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Sensitivity<T> operator +(Sensitivity<T> left, Sensitivity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Sensitivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Sensitivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sensitivity<T> operator -(Sensitivity<T> value) => Create(-value.Quantity);
+	public static Sensitivity<T> operator *(Sensitivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Sensitivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Sensitivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sensitivity<T> operator *(Sensitivity<T> left, T right) => Create(left.Quantity * right);
+	public static Sensitivity<T> operator *(T left, Sensitivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Sensitivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Sensitivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sensitivity<T> operator *(T left, Sensitivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Sensitivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sensitivity<T> operator /(Sensitivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Sensitivity<T> operator /(Sensitivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Sensitivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs
index beafdd9..c959e2e 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Sharpness.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Sharpness<T> operator +(Sharpness<T> left, Sharpness<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Sharpness{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Sharpness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sharpness<T> operator -(Sharpness<T> value) => Create(-value.Quantity);
+	public static Sharpness<T> operator *(Sharpness<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Sharpness{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Sharpness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sharpness<T> operator *(Sharpness<T> left, T right) => Create(left.Quantity * right);
+	public static Sharpness<T> operator *(T left, Sharpness<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Sharpness{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Sharpness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sharpness<T> operator *(T left, Sharpness<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Sharpness{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Sharpness<T> operator /(Sharpness<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Sharpness<T> operator /(Sharpness<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Sharpness{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 abb1a46..633f698 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ShearModulus{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ShearModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ShearModulus<T> operator -(ShearModulus<T> value) => Create(-value.Quantity);
+	public static ShearModulus<T> operator *(ShearModulus<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ShearModulus{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ShearModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ShearModulus<T> operator *(ShearModulus<T> left, T right) => Create(left.Quantity * right);
+	public static ShearModulus<T> operator *(T left, ShearModulus<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ShearModulus{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ShearModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ShearModulus<T> operator *(T left, ShearModulus<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ShearModulus{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ShearModulus<T> operator /(ShearModulus<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ShearModulus<T> operator /(ShearModulus<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ShearModulus{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs
index fb515ec..556f49f 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SnapMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SnapMagnitude<T> operator +(SnapMagnitude<T> left, SnapMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SnapMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SnapMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SnapMagnitude<T> operator -(SnapMagnitude<T> value) => Create(-value.Quantity);
+	public static SnapMagnitude<T> operator *(SnapMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SnapMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SnapMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SnapMagnitude<T> operator *(SnapMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static SnapMagnitude<T> operator *(T left, SnapMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SnapMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SnapMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SnapMagnitude<T> operator *(T left, SnapMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SnapMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SnapMagnitude<T> operator /(SnapMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SnapMagnitude<T> operator /(SnapMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SnapMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 e34acbd..e822d6b 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SoundAbsorption{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SoundAbsorption{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundAbsorption<T> operator -(SoundAbsorption<T> value) => Create(-value.Quantity);
+	public static SoundAbsorption<T> operator *(SoundAbsorption<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SoundAbsorption{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SoundAbsorption{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundAbsorption<T> operator *(SoundAbsorption<T> left, T right) => Create(left.Quantity * right);
+	public static SoundAbsorption<T> operator *(T left, SoundAbsorption<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SoundAbsorption{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SoundAbsorption{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundAbsorption<T> operator *(T left, SoundAbsorption<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SoundAbsorption{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundAbsorption<T> operator /(SoundAbsorption<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SoundAbsorption<T> operator /(SoundAbsorption<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SoundAbsorption{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 bee82a8..75bf010 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SoundIntensity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SoundIntensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundIntensity<T> operator -(SoundIntensity<T> value) => Create(-value.Quantity);
+	public static SoundIntensity<T> operator *(SoundIntensity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SoundIntensity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SoundIntensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundIntensity<T> operator *(SoundIntensity<T> left, T right) => Create(left.Quantity * right);
+	public static SoundIntensity<T> operator *(T left, SoundIntensity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SoundIntensity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SoundIntensity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundIntensity<T> operator *(T left, SoundIntensity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SoundIntensity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundIntensity<T> operator /(SoundIntensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SoundIntensity<T> operator /(SoundIntensity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SoundIntensity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 bfc433a..812140a 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SoundPower{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SoundPower{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPower<T> operator -(SoundPower<T> value) => Create(-value.Quantity);
+	public static SoundPower<T> operator *(SoundPower<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SoundPower{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SoundPower{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPower<T> operator *(SoundPower<T> left, T right) => Create(left.Quantity * right);
+	public static SoundPower<T> operator *(T left, SoundPower<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SoundPower{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SoundPower{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPower<T> operator *(T left, SoundPower<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SoundPower{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPower<T> operator /(SoundPower<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SoundPower<T> operator /(SoundPower<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SoundPower{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 144f62f..0a49273 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SoundPressure{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SoundPressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPressure<T> operator -(SoundPressure<T> value) => Create(-value.Quantity);
+	public static SoundPressure<T> operator *(SoundPressure<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SoundPressure{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SoundPressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPressure<T> operator *(SoundPressure<T> left, T right) => Create(left.Quantity * right);
+	public static SoundPressure<T> operator *(T left, SoundPressure<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SoundPressure{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SoundPressure{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPressure<T> operator *(T left, SoundPressure<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SoundPressure{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundPressure<T> operator /(SoundPressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SoundPressure<T> operator /(SoundPressure<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SoundPressure{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 4152f24..d8ec17c 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SoundSpeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SoundSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundSpeed<T> operator -(SoundSpeed<T> value) => Create(-value.Quantity);
+	public static SoundSpeed<T> operator *(SoundSpeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SoundSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SoundSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundSpeed<T> operator *(SoundSpeed<T> left, T right) => Create(left.Quantity * right);
+	public static SoundSpeed<T> operator *(T left, SoundSpeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SoundSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SoundSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundSpeed<T> operator *(T left, SoundSpeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SoundSpeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundSpeed<T> operator /(SoundSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SoundSpeed<T> operator /(SoundSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SoundSpeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 7c6cc28..935cb85 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SoundTransmissionClass{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SoundTransmissionClass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundTransmissionClass<T> operator -(SoundTransmissionClass<T> value) => Create(-value.Quantity);
+	public static SoundTransmissionClass<T> operator *(SoundTransmissionClass<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SoundTransmissionClass{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SoundTransmissionClass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundTransmissionClass<T> operator *(SoundTransmissionClass<T> left, T right) => Create(left.Quantity * right);
+	public static SoundTransmissionClass<T> operator *(T left, SoundTransmissionClass<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SoundTransmissionClass{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SoundTransmissionClass{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundTransmissionClass<T> operator *(T left, SoundTransmissionClass<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SoundTransmissionClass{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SoundTransmissionClass<T> operator /(SoundTransmissionClass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SoundTransmissionClass<T> operator /(SoundTransmissionClass<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SoundTransmissionClass{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentumMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentumMagnitude.g.cs
index 28996b0..acd5129 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentumMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificAngularMomentumMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SpecificAngularMomentumMagnitude<T> operator +(SpecificAngularMomentumMagnitude<T> left, SpecificAngularMomentumMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SpecificAngularMomentumMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SpecificAngularMomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificAngularMomentumMagnitude<T> operator -(SpecificAngularMomentumMagnitude<T> value) => Create(-value.Quantity);
+	public static SpecificAngularMomentumMagnitude<T> operator *(SpecificAngularMomentumMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SpecificAngularMomentumMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SpecificAngularMomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificAngularMomentumMagnitude<T> operator *(SpecificAngularMomentumMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static SpecificAngularMomentumMagnitude<T> operator *(T left, SpecificAngularMomentumMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SpecificAngularMomentumMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SpecificAngularMomentumMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificAngularMomentumMagnitude<T> operator *(T left, SpecificAngularMomentumMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SpecificAngularMomentumMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificAngularMomentumMagnitude<T> operator /(SpecificAngularMomentumMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SpecificAngularMomentumMagnitude<T> operator /(SpecificAngularMomentumMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SpecificAngularMomentumMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEnergyMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEnergyMagnitude.g.cs
index ab34e4b..88d1b58 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEnergyMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificEnergyMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SpecificEnergyMagnitude<T> operator +(SpecificEnergyMagnitude<T> left, SpecificEnergyMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SpecificEnergyMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SpecificEnergyMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEnergyMagnitude<T> operator -(SpecificEnergyMagnitude<T> value) => Create(-value.Quantity);
+	public static SpecificEnergyMagnitude<T> operator *(SpecificEnergyMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SpecificEnergyMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SpecificEnergyMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEnergyMagnitude<T> operator *(SpecificEnergyMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static SpecificEnergyMagnitude<T> operator *(T left, SpecificEnergyMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SpecificEnergyMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SpecificEnergyMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEnergyMagnitude<T> operator *(T left, SpecificEnergyMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SpecificEnergyMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEnergyMagnitude<T> operator /(SpecificEnergyMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SpecificEnergyMagnitude<T> operator /(SpecificEnergyMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SpecificEnergyMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 9e661fa..1a873b3 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SpecificEntropy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SpecificEntropy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEntropy<T> operator -(SpecificEntropy<T> value) => Create(-value.Quantity);
+	public static SpecificEntropy<T> operator *(SpecificEntropy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SpecificEntropy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SpecificEntropy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEntropy<T> operator *(SpecificEntropy<T> left, T right) => Create(left.Quantity * right);
+	public static SpecificEntropy<T> operator *(T left, SpecificEntropy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SpecificEntropy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SpecificEntropy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEntropy<T> operator *(T left, SpecificEntropy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SpecificEntropy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificEntropy<T> operator /(SpecificEntropy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SpecificEntropy<T> operator /(SpecificEntropy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SpecificEntropy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 82b6502..103a541 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SpecificGravity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SpecificGravity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificGravity<T> operator -(SpecificGravity<T> value) => Create(-value.Quantity);
+	public static SpecificGravity<T> operator *(SpecificGravity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SpecificGravity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SpecificGravity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificGravity<T> operator *(SpecificGravity<T> left, T right) => Create(left.Quantity * right);
+	public static SpecificGravity<T> operator *(T left, SpecificGravity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SpecificGravity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SpecificGravity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificGravity<T> operator *(T left, SpecificGravity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SpecificGravity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificGravity<T> operator /(SpecificGravity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SpecificGravity<T> operator /(SpecificGravity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SpecificGravity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs
index 930bcb6..8337316 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SpecificHeat.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SpecificHeat<T> operator +(SpecificHeat<T> left, SpecificHeat<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SpecificHeat{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SpecificHeat{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificHeat<T> operator -(SpecificHeat<T> value) => Create(-value.Quantity);
+	public static SpecificHeat<T> operator *(SpecificHeat<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SpecificHeat{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SpecificHeat{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificHeat<T> operator *(SpecificHeat<T> left, T right) => Create(left.Quantity * right);
+	public static SpecificHeat<T> operator *(T left, SpecificHeat<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SpecificHeat{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SpecificHeat{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificHeat<T> operator *(T left, SpecificHeat<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SpecificHeat{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificHeat<T> operator /(SpecificHeat<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SpecificHeat<T> operator /(SpecificHeat<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SpecificHeat{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 b3dbc35..9ef0531 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SpecificKineticEnergy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SpecificKineticEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificKineticEnergy<T> operator -(SpecificKineticEnergy<T> value) => Create(-value.Quantity);
+	public static SpecificKineticEnergy<T> operator *(SpecificKineticEnergy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SpecificKineticEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SpecificKineticEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificKineticEnergy<T> operator *(SpecificKineticEnergy<T> left, T right) => Create(left.Quantity * right);
+	public static SpecificKineticEnergy<T> operator *(T left, SpecificKineticEnergy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SpecificKineticEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SpecificKineticEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificKineticEnergy<T> operator *(T left, SpecificKineticEnergy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SpecificKineticEnergy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SpecificKineticEnergy<T> operator /(SpecificKineticEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SpecificKineticEnergy<T> operator /(SpecificKineticEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SpecificKineticEnergy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 337e614..ecac9e0 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Speed<T> operator +(Speed<T> left, Speed<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Speed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Speed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator -(Speed<T> value) => Create(-value.Quantity);
+	public static Speed<T> operator *(Speed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Speed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Speed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator *(Speed<T> left, T right) => Create(left.Quantity * right);
+	public static Speed<T> operator *(T left, Speed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Speed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Speed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator *(T left, Speed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Speed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Speed<T> operator /(Speed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Speed<T> operator /(Speed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Speed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 d520aaf..74c69c8 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="StandardGravitationalParameter{T}"/>.</summary>
+	/// <summary>Scales a <see cref="StandardGravitationalParameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static StandardGravitationalParameter<T> operator -(StandardGravitationalParameter<T> value) => Create(-value.Quantity);
+	public static StandardGravitationalParameter<T> operator *(StandardGravitationalParameter<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="StandardGravitationalParameter{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="StandardGravitationalParameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static StandardGravitationalParameter<T> operator *(StandardGravitationalParameter<T> left, T right) => Create(left.Quantity * right);
+	public static StandardGravitationalParameter<T> operator *(T left, StandardGravitationalParameter<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="StandardGravitationalParameter{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="StandardGravitationalParameter{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static StandardGravitationalParameter<T> operator *(T left, StandardGravitationalParameter<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="StandardGravitationalParameter{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static StandardGravitationalParameter<T> operator /(StandardGravitationalParameter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static StandardGravitationalParameter<T> operator /(StandardGravitationalParameter<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="StandardGravitationalParameter{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 57fe698..f73f0f7 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Stress{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Stress{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Stress<T> operator -(Stress<T> value) => Create(-value.Quantity);
+	public static Stress<T> operator *(Stress<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Stress{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Stress{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Stress<T> operator *(Stress<T> left, T right) => Create(left.Quantity * right);
+	public static Stress<T> operator *(T left, Stress<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Stress{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Stress{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Stress<T> operator *(T left, Stress<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Stress{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Stress<T> operator /(Stress<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Stress<T> operator /(Stress<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Stress{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 7580b2b..3e81fd4 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SurfaceArea{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SurfaceArea{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceArea<T> operator -(SurfaceArea<T> value) => Create(-value.Quantity);
+	public static SurfaceArea<T> operator *(SurfaceArea<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SurfaceArea{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SurfaceArea{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceArea<T> operator *(SurfaceArea<T> left, T right) => Create(left.Quantity * right);
+	public static SurfaceArea<T> operator *(T left, SurfaceArea<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SurfaceArea{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SurfaceArea{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceArea<T> operator *(T left, SurfaceArea<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SurfaceArea{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceArea<T> operator /(SurfaceArea<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SurfaceArea<T> operator /(SurfaceArea<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SurfaceArea{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs
index 83df84d..f937eab 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/SurfaceTension.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static SurfaceTension<T> operator +(SurfaceTension<T> left, SurfaceTension<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="SurfaceTension{T}"/>.</summary>
+	/// <summary>Scales a <see cref="SurfaceTension{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceTension<T> operator -(SurfaceTension<T> value) => Create(-value.Quantity);
+	public static SurfaceTension<T> operator *(SurfaceTension<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="SurfaceTension{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="SurfaceTension{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceTension<T> operator *(SurfaceTension<T> left, T right) => Create(left.Quantity * right);
+	public static SurfaceTension<T> operator *(T left, SurfaceTension<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="SurfaceTension{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="SurfaceTension{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceTension<T> operator *(T left, SurfaceTension<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="SurfaceTension{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static SurfaceTension<T> operator /(SurfaceTension<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static SurfaceTension<T> operator /(SurfaceTension<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="SurfaceTension{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs
index b58c76e..5ccb976 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Temperature.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Temperature<T> operator +(Temperature<T> left, Temperature<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Temperature{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Temperature{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Temperature<T> operator -(Temperature<T> value) => Create(-value.Quantity);
+	public static Temperature<T> operator *(Temperature<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Temperature{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Temperature{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Temperature<T> operator *(Temperature<T> left, T right) => Create(left.Quantity * right);
+	public static Temperature<T> operator *(T left, Temperature<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Temperature{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Temperature{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Temperature<T> operator *(T left, Temperature<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Temperature{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Temperature<T> operator /(Temperature<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Temperature<T> operator /(Temperature<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Temperature{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 e49a64b..e9eec34 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Tension{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Tension{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Tension<T> operator -(Tension<T> value) => Create(-value.Quantity);
+	public static Tension<T> operator *(Tension<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Tension{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Tension{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Tension<T> operator *(Tension<T> left, T right) => Create(left.Quantity * right);
+	public static Tension<T> operator *(T left, Tension<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Tension{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Tension{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Tension<T> operator *(T left, Tension<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Tension{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Tension<T> operator /(Tension<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Tension<T> operator /(Tension<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Tension{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs
index cb46250..a690039 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalConductivity.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ThermalConductivity<T> operator +(ThermalConductivity<T> left, ThermalConductivity<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ThermalConductivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ThermalConductivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalConductivity<T> operator -(ThermalConductivity<T> value) => Create(-value.Quantity);
+	public static ThermalConductivity<T> operator *(ThermalConductivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ThermalConductivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ThermalConductivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalConductivity<T> operator *(ThermalConductivity<T> left, T right) => Create(left.Quantity * right);
+	public static ThermalConductivity<T> operator *(T left, ThermalConductivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ThermalConductivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ThermalConductivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalConductivity<T> operator *(T left, ThermalConductivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ThermalConductivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalConductivity<T> operator /(ThermalConductivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ThermalConductivity<T> operator /(ThermalConductivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ThermalConductivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 e752eac..c525e3a 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ThermalDiffusivity{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ThermalDiffusivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalDiffusivity<T> operator -(ThermalDiffusivity<T> value) => Create(-value.Quantity);
+	public static ThermalDiffusivity<T> operator *(ThermalDiffusivity<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ThermalDiffusivity{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ThermalDiffusivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalDiffusivity<T> operator *(ThermalDiffusivity<T> left, T right) => Create(left.Quantity * right);
+	public static ThermalDiffusivity<T> operator *(T left, ThermalDiffusivity<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ThermalDiffusivity{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ThermalDiffusivity{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalDiffusivity<T> operator *(T left, ThermalDiffusivity<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ThermalDiffusivity{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalDiffusivity<T> operator /(ThermalDiffusivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ThermalDiffusivity<T> operator /(ThermalDiffusivity<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ThermalDiffusivity{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 a540c71..5c511ff 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ThermalEnergy{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ThermalEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalEnergy<T> operator -(ThermalEnergy<T> value) => Create(-value.Quantity);
+	public static ThermalEnergy<T> operator *(ThermalEnergy<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ThermalEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ThermalEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalEnergy<T> operator *(ThermalEnergy<T> left, T right) => Create(left.Quantity * right);
+	public static ThermalEnergy<T> operator *(T left, ThermalEnergy<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ThermalEnergy{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ThermalEnergy{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalEnergy<T> operator *(T left, ThermalEnergy<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ThermalEnergy{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalEnergy<T> operator /(ThermalEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ThermalEnergy<T> operator /(ThermalEnergy<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ThermalEnergy{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs
index d71b0a7..f18e67d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalExpansionCoefficient.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ThermalExpansionCoefficient<T> operator +(ThermalExpansionCoefficient<T> left, ThermalExpansionCoefficient<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ThermalExpansionCoefficient{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ThermalExpansionCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalExpansionCoefficient<T> operator -(ThermalExpansionCoefficient<T> value) => Create(-value.Quantity);
+	public static ThermalExpansionCoefficient<T> operator *(ThermalExpansionCoefficient<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ThermalExpansionCoefficient{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ThermalExpansionCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalExpansionCoefficient<T> operator *(ThermalExpansionCoefficient<T> left, T right) => Create(left.Quantity * right);
+	public static ThermalExpansionCoefficient<T> operator *(T left, ThermalExpansionCoefficient<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ThermalExpansionCoefficient{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ThermalExpansionCoefficient{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalExpansionCoefficient<T> operator *(T left, ThermalExpansionCoefficient<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ThermalExpansionCoefficient{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalExpansionCoefficient<T> operator /(ThermalExpansionCoefficient<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ThermalExpansionCoefficient<T> operator /(ThermalExpansionCoefficient<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ThermalExpansionCoefficient{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs
index c91223a..eecd3fb 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/ThermalResistance.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static ThermalResistance<T> operator +(ThermalResistance<T> left, ThermalResistance<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="ThermalResistance{T}"/>.</summary>
+	/// <summary>Scales a <see cref="ThermalResistance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalResistance<T> operator -(ThermalResistance<T> value) => Create(-value.Quantity);
+	public static ThermalResistance<T> operator *(ThermalResistance<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="ThermalResistance{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="ThermalResistance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalResistance<T> operator *(ThermalResistance<T> left, T right) => Create(left.Quantity * right);
+	public static ThermalResistance<T> operator *(T left, ThermalResistance<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="ThermalResistance{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="ThermalResistance{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalResistance<T> operator *(T left, ThermalResistance<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="ThermalResistance{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static ThermalResistance<T> operator /(ThermalResistance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static ThermalResistance<T> operator /(ThermalResistance<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="ThermalResistance{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 d748c0a..6eae6e8 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Thickness{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Thickness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thickness<T> operator -(Thickness<T> value) => Create(-value.Quantity);
+	public static Thickness<T> operator *(Thickness<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Thickness{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Thickness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thickness<T> operator *(Thickness<T> left, T right) => Create(left.Quantity * right);
+	public static Thickness<T> operator *(T left, Thickness<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Thickness{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Thickness{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thickness<T> operator *(T left, Thickness<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Thickness{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thickness<T> operator /(Thickness<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Thickness<T> operator /(Thickness<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Thickness{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 b9daa8b..faaea69 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Thrust{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Thrust{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thrust<T> operator -(Thrust<T> value) => Create(-value.Quantity);
+	public static Thrust<T> operator *(Thrust<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Thrust{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Thrust{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thrust<T> operator *(Thrust<T> left, T right) => Create(left.Quantity * right);
+	public static Thrust<T> operator *(T left, Thrust<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Thrust{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Thrust{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thrust<T> operator *(T left, Thrust<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Thrust{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Thrust<T> operator /(Thrust<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Thrust<T> operator /(Thrust<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Thrust{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 beb64aa..2524740 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="TimeConstant{T}"/>.</summary>
+	/// <summary>Scales a <see cref="TimeConstant{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TimeConstant<T> operator -(TimeConstant<T> value) => Create(-value.Quantity);
+	public static TimeConstant<T> operator *(TimeConstant<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="TimeConstant{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="TimeConstant{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TimeConstant<T> operator *(TimeConstant<T> left, T right) => Create(left.Quantity * right);
+	public static TimeConstant<T> operator *(T left, TimeConstant<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="TimeConstant{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="TimeConstant{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TimeConstant<T> operator *(T left, TimeConstant<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="TimeConstant{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TimeConstant<T> operator /(TimeConstant<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static TimeConstant<T> operator /(TimeConstant<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="TimeConstant{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs
index de14d6d..0bd926d 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/TorqueMagnitude.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static TorqueMagnitude<T> operator +(TorqueMagnitude<T> left, TorqueMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="TorqueMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="TorqueMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TorqueMagnitude<T> operator -(TorqueMagnitude<T> value) => Create(-value.Quantity);
+	public static TorqueMagnitude<T> operator *(TorqueMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="TorqueMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="TorqueMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TorqueMagnitude<T> operator *(TorqueMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static TorqueMagnitude<T> operator *(T left, TorqueMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="TorqueMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="TorqueMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TorqueMagnitude<T> operator *(T left, TorqueMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="TorqueMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static TorqueMagnitude<T> operator /(TorqueMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static TorqueMagnitude<T> operator /(TorqueMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="TorqueMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 efdcfb0..12a202d 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="VoltageDrop{T}"/>.</summary>
+	/// <summary>Scales a <see cref="VoltageDrop{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageDrop<T> operator -(VoltageDrop<T> value) => Create(-value.Quantity);
+	public static VoltageDrop<T> operator *(VoltageDrop<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="VoltageDrop{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="VoltageDrop{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageDrop<T> operator *(VoltageDrop<T> left, T right) => Create(left.Quantity * right);
+	public static VoltageDrop<T> operator *(T left, VoltageDrop<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="VoltageDrop{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="VoltageDrop{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageDrop<T> operator *(T left, VoltageDrop<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="VoltageDrop{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageDrop<T> operator /(VoltageDrop<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static VoltageDrop<T> operator /(VoltageDrop<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="VoltageDrop{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 d96c284..45349ab 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static VoltageMagnitude<T> operator +(VoltageMagnitude<T> left, VoltageMagnitude<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="VoltageMagnitude{T}"/>.</summary>
+	/// <summary>Scales a <see cref="VoltageMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator -(VoltageMagnitude<T> value) => Create(-value.Quantity);
+	public static VoltageMagnitude<T> operator *(VoltageMagnitude<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="VoltageMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="VoltageMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator *(VoltageMagnitude<T> left, T right) => Create(left.Quantity * right);
+	public static VoltageMagnitude<T> operator *(T left, VoltageMagnitude<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="VoltageMagnitude{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="VoltageMagnitude{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator *(T left, VoltageMagnitude<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="VoltageMagnitude{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VoltageMagnitude<T> operator /(VoltageMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static VoltageMagnitude<T> operator /(VoltageMagnitude<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="VoltageMagnitude{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 8146e09..a90a46c 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
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static Volume<T> operator +(Volume<T> left, Volume<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Volume{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Volume{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator -(Volume<T> value) => Create(-value.Quantity);
+	public static Volume<T> operator *(Volume<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Volume{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Volume{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator *(Volume<T> left, T right) => Create(left.Quantity * right);
+	public static Volume<T> operator *(T left, Volume<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Volume{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Volume{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator *(T left, Volume<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Volume{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Volume<T> operator /(Volume<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Volume<T> operator /(Volume<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Volume{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs
index 40d3272..04ef3d7 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/VolumetricFlowRate.g.cs
@@ -53,21 +53,17 @@ namespace ktsu.Semantics.Quantities;
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
 	public static VolumetricFlowRate<T> operator +(VolumetricFlowRate<T> left, VolumetricFlowRate<T> right) => Create(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="VolumetricFlowRate{T}"/>.</summary>
+	/// <summary>Scales a <see cref="VolumetricFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VolumetricFlowRate<T> operator -(VolumetricFlowRate<T> value) => Create(-value.Quantity);
+	public static VolumetricFlowRate<T> operator *(VolumetricFlowRate<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="VolumetricFlowRate{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="VolumetricFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VolumetricFlowRate<T> operator *(VolumetricFlowRate<T> left, T right) => Create(left.Quantity * right);
+	public static VolumetricFlowRate<T> operator *(T left, VolumetricFlowRate<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="VolumetricFlowRate{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="VolumetricFlowRate{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VolumetricFlowRate<T> operator *(T left, VolumetricFlowRate<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="VolumetricFlowRate{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static VolumetricFlowRate<T> operator /(VolumetricFlowRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static VolumetricFlowRate<T> operator /(VolumetricFlowRate<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="VolumetricFlowRate{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 1129548..6227d84 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,21 +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>Negates a <see cref="Wavelength{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Wavelength<T> operator -(Wavelength<T> value) => Create(-value.Quantity);
+	public static Wavelength<T> operator *(Wavelength<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</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(left.Quantity * right);
+	public static Wavelength<T> operator *(T left, Wavelength<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Wavelength{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Wavelength{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</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(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Wavelength{T}"/> by a bare number.</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(left.Quantity / right);
+	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)));
 
 	/// <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")]
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 39a8d92..315d9e5 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Weight{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Weight{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Weight<T> operator -(Weight<T> value) => Create(-value.Quantity);
+	public static Weight<T> operator *(Weight<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Weight{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Weight{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Weight<T> operator *(Weight<T> left, T right) => Create(left.Quantity * right);
+	public static Weight<T> operator *(T left, Weight<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Weight{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Weight{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Weight<T> operator *(T left, Weight<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Weight{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Weight<T> operator /(Weight<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Weight<T> operator /(Weight<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Weight{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 921f99a..a74b2be 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Width{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Width{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Width<T> operator -(Width<T> value) => Create(-value.Quantity);
+	public static Width<T> operator *(Width<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Width{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Width{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Width<T> operator *(Width<T> left, T right) => Create(left.Quantity * right);
+	public static Width<T> operator *(T left, Width<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Width{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Width{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Width<T> operator *(T left, Width<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Width{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Width<T> operator /(Width<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Width<T> operator /(Width<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Width{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 33cc705..2d8c9fe 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="WindSpeed{T}"/>.</summary>
+	/// <summary>Scales a <see cref="WindSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static WindSpeed<T> operator -(WindSpeed<T> value) => Create(-value.Quantity);
+	public static WindSpeed<T> operator *(WindSpeed<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="WindSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="WindSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static WindSpeed<T> operator *(WindSpeed<T> left, T right) => Create(left.Quantity * right);
+	public static WindSpeed<T> operator *(T left, WindSpeed<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="WindSpeed{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="WindSpeed{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static WindSpeed<T> operator *(T left, WindSpeed<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="WindSpeed{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static WindSpeed<T> operator /(WindSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static WindSpeed<T> operator /(WindSpeed<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="WindSpeed{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 25f2e20..7852c59 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="Work{T}"/>.</summary>
+	/// <summary>Scales a <see cref="Work{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Work<T> operator -(Work<T> value) => Create(-value.Quantity);
+	public static Work<T> operator *(Work<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="Work{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="Work{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Work<T> operator *(Work<T> left, T right) => Create(left.Quantity * right);
+	public static Work<T> operator *(T left, Work<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="Work{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="Work{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Work<T> operator *(T left, Work<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="Work{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static Work<T> operator /(Work<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static Work<T> operator /(Work<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="Work{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
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 84da184..98fcf3d 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
@@ -54,21 +54,17 @@ namespace ktsu.Semantics.Quantities;
 	[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(left.Quantity + right.Quantity);
 
-	/// <summary>Negates a <see cref="YoungsModulus{T}"/>.</summary>
+	/// <summary>Scales a <see cref="YoungsModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static YoungsModulus<T> operator -(YoungsModulus<T> value) => Create(-value.Quantity);
+	public static YoungsModulus<T> operator *(YoungsModulus<T> left, T right) => Create(Vector0Guards.EnsureNonNegative(left.Quantity * right, nameof(right)));
 
-	/// <summary>Scales a <see cref="YoungsModulus{T}"/> by a bare number.</summary>
+	/// <summary>Scales a <see cref="YoungsModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static YoungsModulus<T> operator *(YoungsModulus<T> left, T right) => Create(left.Quantity * right);
+	public static YoungsModulus<T> operator *(T left, YoungsModulus<T> right) => Create(Vector0Guards.EnsureNonNegative(left * right.Quantity, nameof(left)));
 
-	/// <summary>Scales a <see cref="YoungsModulus{T}"/> by a bare number.</summary>
+	/// <summary>Divides a <see cref="YoungsModulus{T}"/> by a bare number. Throws <see cref="System.ArgumentException"/> when the number is negative.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static YoungsModulus<T> operator *(T left, YoungsModulus<T> right) => Create(left * right.Quantity);
-
-	/// <summary>Divides a <see cref="YoungsModulus{T}"/> by a bare number.</summary>
-	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
-	public static YoungsModulus<T> operator /(YoungsModulus<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(left.Quantity / right);
+	public static YoungsModulus<T> operator /(YoungsModulus<T> left, T right) => T.IsZero(right) ? throw new System.DivideByZeroException("Cannot divide by zero.") : Create(Vector0Guards.EnsureNonNegative(left.Quantity / right, nameof(right)));
 
 	/// <summary>Divides one <see cref="YoungsModulus{T}"/> by another, giving the bare ratio.</summary>
 	[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2225:Operator overloads have named alternates", Justification = "Physics quantity operator")]
diff --git a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
index 9209f06..0cda3e0 100644
--- a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
@@ -847,23 +847,35 @@ private static void AddValueTypeCore(ClassTemplate cls, string fullType, bool is
 				$"Subtracts one {docRef} from another.");
 		}
 
-		cls.Members.Add(new MethodTemplate()
+		// A magnitude has no negation, and scaling one by a negative number throws, for the same
+		// reason binary '-' is withheld above: a V0 never holds a negative value (#285). The
+		// factories guard construction (#50); these are the operators that could otherwise get
+		// past them.
+		if (!isV0)
 		{
-			Comments = {$"/// <summary>Negates a {docRef}.</summary>"},
-			Attributes = {Emit.PhysicsOperatorSuppression},
-			Keywords = {Emit.Public, Emit.Static, fullType},
-			Name = "operator -",
-			Parameters = {new ParameterTemplate { Type = fullType, Name = Emit.ValueParameter }},
-			BodyFactory = (body) => body.Write("=> Create(-value.Quantity);"),
-		});
+			cls.Members.Add(new MethodTemplate()
+			{
+				Comments = {$"/// <summary>Negates a {docRef}.</summary>"},
+				Attributes = {Emit.PhysicsOperatorSuppression},
+				Keywords = {Emit.Public, Emit.Static, fullType},
+				Name = "operator -",
+				Parameters = {new ParameterTemplate { Type = fullType, Name = Emit.ValueParameter }},
+				BodyFactory = (body) => body.Write("=> Create(-value.Quantity);"),
+			});
+		}
+
+		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;
 
-		AddBinaryOperator(cls, fullType, "*", fullType, "T", "=> Create(left.Quantity * right);",
-			$"Scales a {docRef} by a bare number.");
-		AddBinaryOperator(cls, fullType, "*", "T", fullType, "=> Create(left * right.Quantity);",
-			$"Scales a {docRef} by a bare number.");
+		AddBinaryOperator(cls, fullType, "*", fullType, "T", $"=> {scaledLeft};",
+			$"Scales a {docRef} by a bare number.{scaleRemark}");
+		AddBinaryOperator(cls, fullType, "*", "T", fullType, $"=> {scaledRight};",
+			$"Scales a {docRef} by a bare number.{scaleRemark}");
 		AddBinaryOperator(cls, fullType, "/", fullType, "T",
-			"=> T.IsZero(right) ? throw new System.DivideByZeroException(\"Cannot divide by zero.\") : Create(left.Quantity / right);",
-			$"Divides a {docRef} by a bare number.");
+			$"=> T.IsZero(right) ? throw new System.DivideByZeroException(\"Cannot divide by zero.\") : {divided};",
+			$"Divides a {docRef} by a bare number.{scaleRemark}");
 		AddBinaryOperator(cls, "T", "/", fullType, fullType,
 			"=> T.IsZero(right.Quantity) ? throw new System.DivideByZeroException(\"Cannot divide by zero.\") : left.Quantity / right.Quantity;",
 			$"Divides one {docRef} by another, giving the bare ratio.");
diff --git a/Semantics.Test/Quantities/Vector0InvariantTests.cs b/Semantics.Test/Quantities/Vector0InvariantTests.cs
index f1a27eb..af58da1 100644
--- a/Semantics.Test/Quantities/Vector0InvariantTests.cs
+++ b/Semantics.Test/Quantities/Vector0InvariantTests.cs
@@ -11,6 +11,7 @@ namespace ktsu.Semantics.Test.Quantities;
 /// <list type="bullet">
 /// <item><description>Issue #50: factories reject negative inputs with <see cref="ArgumentException"/>.</description></item>
 /// <item><description>Issue #52: V0 - V0 returns the same V0 of <c>T.Abs(a - b)</c>.</description></item>
+/// <item><description>Issue #285: a V0 has no unary negation, and scaling it by a negative number throws.</description></item>
 /// </list>
 /// </summary>
 [TestClass]
@@ -281,4 +282,54 @@ public void Vector0Guards_EnsurePositive_Throws_On_Negative_With_ParamName()
 			() => Vector0Guards.EnsurePositive(-1.0, "myParam"));
 		Assert.AreEqual("myParam", ex.ParamName);
 	}
+
+	// =========================================================== #285: Operators cannot make a V0 negative
+
+	[TestMethod]
+	public void Vector0_Has_No_Unary_Negation()
+	{
+		Assert.IsNull(typeof(Temperature<double>).GetMethod("op_UnaryNegation"));
+		Assert.IsNull(typeof(Speed<double>).GetMethod("op_UnaryNegation"));
+		Assert.IsNull(typeof(Distance<double>).GetMethod("op_UnaryNegation"));
+	}
+
+	[TestMethod]
+	public void Vector1_Keeps_Unary_Negation()
+	{
+		Velocity1D<double> v = -Velocity1D<double>.FromMeterPerSecond(3.0);
+		Assert.AreEqual(-3.0, v.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void Vector0_Times_Negative_Scalar_Throws()
+	{
+		Speed<double> speed = Speed<double>.FromMeterPerSecond(2.0);
+		_ = Assert.ThrowsExactly<ArgumentException>(() => speed * -3.0);
+		_ = Assert.ThrowsExactly<ArgumentException>(() => -3.0 * speed);
+	}
+
+	[TestMethod]
+	public void Vector0_Divided_By_Negative_Scalar_Throws()
+	{
+		Temperature<double> temperature = Temperature<double>.FromKelvin(300.0);
+		_ = Assert.ThrowsExactly<ArgumentException>(() => temperature / -2.0);
+	}
+
+	[TestMethod]
+	public void Vector0_Overload_Times_Negative_Scalar_Throws()
+		=> _ = Assert.ThrowsExactly<ArgumentException>(() => Distance<double>.FromMeter(1.0) * -1.0);
+
+	[TestMethod]
+	public void Vector0_Scaled_By_NonNegative_Scalar_Is_Allowed()
+	{
+		Speed<double> speed = Speed<double>.FromMeterPerSecond(2.0);
+		Assert.AreEqual(6.0, (speed * 3.0).Value, Tolerance);
+		Assert.AreEqual(6.0, (3.0 * speed).Value, Tolerance);
+		Assert.AreEqual(1.0, (speed / 2.0).Value, Tolerance);
+		Assert.AreEqual(0.0, (speed * 0.0).Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void Vector1_Scaled_By_Negative_Scalar_Is_Signed()
+		=> Assert.AreEqual(-6.0, (Velocity1D<double>.FromMeterPerSecond(2.0) * -3.0).Value, Tolerance);
 }
diff --git a/docs/complete-library-guide.md b/docs/complete-library-guide.md
index 7ff4be3..795feed 100644
--- a/docs/complete-library-guide.md
+++ b/docs/complete-library-guide.md
@@ -134,7 +134,7 @@ Every quantity is a vector. Direction-space dimensionality is part of the type:
 
 The model and its rationale live in `strategy-unified-vector-quantities.md`. Rules of thumb:
 
-- A `Vector0` is *always* non-negative. `Speed.Create(-1)` throws.
+- A `Vector0` is *always* non-negative. `Speed.FromMeterPerSecond(-1)` throws, as does scaling a `Vector0` by a negative number, and a `Vector0` has no unary `-`. `Create` is the unguarded primitive the generated code builds on, and does not check.
 - `V0 - V0` returns the same `V0` of `T.Abs(a - b)` (signed subtraction must use V1 explicitly).
 - A semantic overload (e.g. `Weight` over `ForceMagnitude`) implicitly widens to its base; narrowing is explicit.
 - All values are stored in SI base units.