From ebcd43427414896f240723bcf43e3c8d031c588b Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 13 Oct 2026 04:25:26 +0000
Subject: [PATCH] Reject NaN in Vector0 guards with ArgumentException [patch]

T.Sign(NaN) throws ArithmeticException for double, float and Half, so
the documented ArgumentException was never reached. Check T.IsNaN first,
then compare against zero instead of taking the sign.

Fixes #326

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QbGcYckSzgr6jPyoNYhWvA
---
 Semantics.Quantities/Vector0Guards.cs         | 26 +++++++++++---
 .../Quantities/Vector0InvariantTests.cs       | 34 +++++++++++++++++++
 2 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/Semantics.Quantities/Vector0Guards.cs b/Semantics.Quantities/Vector0Guards.cs
index 548d64a6..c0fbc8ba 100644
--- a/Semantics.Quantities/Vector0Guards.cs
+++ b/Semantics.Quantities/Vector0Guards.cs
@@ -27,11 +27,13 @@ public static class Vector0Guards
 	/// <param name="value">The value (already converted to the SI base unit) to validate.</param>
 	/// <param name="paramName">Name of the originating parameter, used for the exception message.</param>
 	/// <returns>The validated, non-negative value.</returns>
-	/// <exception cref="ArgumentException">When <paramref name="value"/> is negative.</exception>
+	/// <exception cref="ArgumentException">When <paramref name="value"/> is NaN or negative.</exception>
 	public static T EnsureNonNegative<T>(T value, string paramName)
 		where T : struct, INumber<T>
 	{
-		if (T.Sign(value) < 0)
+		EnsureNumber(value, paramName);
+
+		if (value < T.Zero)
 		{
 			throw new ArgumentException(
 				$"Magnitude must be non-negative; received {value}.",
@@ -53,11 +55,13 @@ public static T EnsureNonNegative<T>(T value, string paramName)
 	/// <param name="value">The value (already converted to the SI base unit) to validate.</param>
 	/// <param name="paramName">Name of the originating parameter, used for the exception message.</param>
 	/// <returns>The validated, strictly-positive value.</returns>
-	/// <exception cref="ArgumentException">When <paramref name="value"/> is zero or negative.</exception>
+	/// <exception cref="ArgumentException">When <paramref name="value"/> is NaN, zero or negative.</exception>
 	public static T EnsurePositive<T>(T value, string paramName)
 		where T : struct, INumber<T>
 	{
-		if (T.Sign(value) <= 0)
+		EnsureNumber(value, paramName);
+
+		if (value <= T.Zero)
 		{
 			throw new ArgumentException(
 				$"Value must be strictly positive; received {value}.",
@@ -66,4 +70,18 @@ public static T EnsurePositive<T>(T value, string paramName)
 
 		return value;
 	}
+
+	/// <summary>
+	/// Throws <see cref="ArgumentException"/> when <paramref name="value"/> is NaN. Checked before the
+	/// sign test because <c>T.Sign(NaN)</c> throws <see cref="ArithmeticException"/> for the IEEE types,
+	/// and a NaN compares false against zero, so neither test rejects it on its own.
+	/// </summary>
+	private static void EnsureNumber<T>(T value, string paramName)
+		where T : struct, INumber<T>
+	{
+		if (T.IsNaN(value))
+		{
+			throw new ArgumentException("Magnitude must be a number; received NaN.", paramName);
+		}
+	}
 }
diff --git a/Semantics.Test/Quantities/Vector0InvariantTests.cs b/Semantics.Test/Quantities/Vector0InvariantTests.cs
index af58da18..6228feab 100644
--- a/Semantics.Test/Quantities/Vector0InvariantTests.cs
+++ b/Semantics.Test/Quantities/Vector0InvariantTests.cs
@@ -12,6 +12,7 @@ namespace ktsu.Semantics.Test.Quantities;
 /// <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>
+/// <item><description>Issue #326: a NaN input is rejected with <see cref="ArgumentException"/>, not <see cref="ArithmeticException"/>.</description></item>
 /// </list>
 /// </summary>
 [TestClass]
@@ -332,4 +333,37 @@ public void Vector0_Scaled_By_NonNegative_Scalar_Is_Allowed()
 	[TestMethod]
 	public void Vector1_Scaled_By_Negative_Scalar_Is_Signed()
 		=> Assert.AreEqual(-6.0, (Velocity1D<double>.FromMeterPerSecond(2.0) * -3.0).Value, Tolerance);
+
+	// =========================================================== #326: NaN is an ArgumentException
+
+	[TestMethod]
+	public void EnsureNonNegative_NaN_Throws_ArgumentException()
+	{
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsureNonNegative(double.NaN, "value"));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsureNonNegative(float.NaN, "value"));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsureNonNegative(Half.NaN, "value"));
+	}
+
+	[TestMethod]
+	public void EnsurePositive_NaN_Throws_ArgumentException()
+	{
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsurePositive(double.NaN, "value"));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsurePositive(float.NaN, "value"));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsurePositive(Half.NaN, "value"));
+	}
+
+	[TestMethod]
+	public void Generated_Factories_NaN_Throw_ArgumentException()
+	{
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Speed<double>.FromMeterPerSecond(double.NaN));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Mass<double>.FromKilogram(double.NaN));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Wavelength<double>.FromMeter(double.NaN));
+	}
+
+	[TestMethod]
+	public void Guards_Accept_Infinity_And_Reject_NegativeInfinity()
+	{
+		Assert.AreEqual(double.PositiveInfinity, Vector0Guards.EnsurePositive(double.PositiveInfinity, "value"));
+		_ = Assert.ThrowsExactly<ArgumentException>(() => Vector0Guards.EnsureNonNegative(double.NegativeInfinity, "value"));
+	}
 }