Trig / power scalars: SIN / COS / TAN / ASIN / ACOS / ATAN / ATN2 / COT / SQUARE / PI all return float regardless of input numeric category, with NULL propagation, Msg 174 on wrong arg count, and Msg 3623 on domain errors (ASIN/ACOS out of [-1, 1], COT(0), ATN2(0, 0)) — eight unary kinds bundle in TrigFunction.cs via TrigKind discriminator, Atn2.cs / Pi.cs standalone. DEGREES / RADIANS preserve input type except decimal(p, s) → decimal(38, max(s, 18)); integer arm truncates toward zero with Msg 8115 on overflow, decimal arm uses a 28-digit DecimalPi constant in (input * num) / denom order for trailing-digit fidelity. SQUARE overflow → Msg 8115 float.

Author: RyanLamansky

CLAUDE.md

@@ -197,7 +197,7 @@ Integer / money operands canonicalize before formulas apply (bit→(1,0)…bigin
 `SqlType.Promote` (joint-envelope, `scale = max(s1, s2); precision = min(38, max(p1-s1, p2-s2) + scale)`) stays the right rule for non-arithmetic uses.
 
 ### Math scalar functions
-`ABS`, `ROUND` (2- and 3-arg, half-away-from-zero plus truncate mode), `FLOOR`, `CEILING`, `POWER`, `SQRT`, `SIGN`, `LOG` (1- and 2-arg), `EXP`, `LOG10`. EF Core 10 emits all from natural `Math.X` LINQ; `Math.Truncate(x)` → `ROUND(x, 0, 1)`.
+`ABS`, `ROUND` (2- and 3-arg, half-away-from-zero plus truncate mode), `FLOOR`, `CEILING`, `POWER`, `SQRT`, `SIGN`, `LOG` (1- and 2-arg), `EXP`, `LOG10`, the trig family (`SIN` / `COS` / `TAN` / `ASIN` / `ACOS` / `ATAN` / `ATN2` / `COT`), `PI`, `DEGREES` / `RADIANS`, `SQUARE`. EF Core 10 emits all from natural `Math.X` LINQ; `Math.Truncate(x)` → `ROUND(x, 0, 1)`; `Math.Atan2` → `ATN2`.
 
 **Type-widening rule** (shared across `ABS` / `FLOOR` / `CEILING` / `ROUND` / `SIGN` / `POWER`'s first-arg type — probe-confirmed via `SELECT INTO #t` + `tempdb.information_schema.columns`):
 - `tinyint` / `smallint` → `int`
@@ -209,6 +209,10 @@ Integer / money operands canonicalize before formulas apply (bit→(1,0)…bigin
 
 Errors: `SQRT(neg)` / `LOG(<= 0)` / `LOG10(<= 0)` / `LOG(x, 1)` / `POWER(neg, frac)` → Msg 3623. `POWER(0, neg)` → Msg 8134. `EXP` overflow → Msg 8115 float. `ABS(int.MinValue)` / `ABS(bigint.MinValue)` → Msg 8115 with the result type's family in the data-type slot (smallint overflow is absorbed by int widening). `POWER` int-result overflow → Msg 232.
 
+**Trig / power family** (`SIN` / `COS` / `TAN` / `ASIN` / `ACOS` / `ATAN` / `ATN2` / `COT` / `PI` / `SQUARE`): always return `float` regardless of input numeric category — probe-confirmed against SQL Server 2025 (2026-05-10) for int / bigint / decimal / money / float / real / bit / smallmoney inputs. NULL on any operand propagates as typed-NULL float. Domain errors map to Msg 3623: `ASIN` / `ACOS` argument outside `[-1, 1]`, `COT(0)`, `ATN2(0, 0)` (the last diverges from .NET's `Math.Atan2(0, 0) = 0`). `SQUARE` overflow → Msg 8115 float. Wrong arg count → Msg 174 (`"The {lower-name} function requires {N} argument(s)."`) — the eight unary kinds bundle into one `TrigFunction.cs` with a `TrigKind` discriminator since they share NULL / Msg-174 / Msg-3623 paths; `Atn2.cs` (binary) and `Pi.cs` (zero-arg, parens required — `pi(1)` raises Msg 174 not Msg 102) are standalone.
+
+**`DEGREES` / `RADIANS`** are type-preserving with one tweak relative to the shared widening rule above: `decimal(p, s)` widens to `decimal(38, max(s, 18))` rather than preserving — probe-confirmed (`degrees(decimal(10, 2)) → decimal(38, 18)`, `degrees(decimal(38, 30)) → decimal(38, 30)`). Other categories follow `MathScalars.WidenForResult`. The integer arm computes `(double)input * (180/pi)` (or `pi/180`) and truncates toward zero — `DEGREES(360)` → `20626` from `20626.48...`; out-of-range integer results raise Msg 8115 with the result type's family name. The decimal arm uses a 28-digit `DecimalPi` constant in evaluation order `(input * 180m) / DecimalPi` to align trailing digits with SQL Server's emission. .NET decimal's 28-digit precision cap means scale > 28 results land at scale 28 with the type still declaring its full 38-scale envelope (pre-existing decimal-storage quirk). The shared `DegreesRadians.cs` helper holds the integer-arm bound check and decimal-arm rounding logic; the widening-rule divergence stays inline in `Degrees.cs` / `Radians.cs`.
+
 **`Math.Sign(decimal)` doesn't work end-to-end against either real SQL Server or the simulator** (probe-confirmed 2026-05-09): the LINQ method's CLR signature returns `int` but EF emits `SELECT SIGN([col])` and SQL Server's `SIGN(decimal)` returns decimal, so the reader-side cast throws. Same failure mode in both; not a fidelity bug. Apps using `Math.Sign` over an int column work fine. (This is the milestone where the simulator started finding upstream bugs.)
 
 ### Date scalar functions: `DATEPART` / `DATEADD` / `DATEDIFF` / `DATEDIFF_BIG`

SqlServerSimulator.Tests.EFCore/EFCoreMath.cs

@@ -144,6 +144,56 @@ public void Log10_FloatProjection()
         AreClose(1.0915m, (decimal)values[0], 0.001m);
     }
 
+    [TestMethod]
+    public void Trig_SinCosTan_FloatProjection()
+    {
+        // Math.Sin / Cos / Tan emit SIN / COS / TAN with float operands.
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => new
+            {
+                Sin = Math.Sin((double)p.Price),
+                Cos = Math.Cos((double)p.Price),
+                Tan = Math.Tan((double)p.Price),
+            })
+            .ToArray();
+        AreClose((decimal)Math.Sin(12.35), (decimal)values[0].Sin, 0.001m);
+        AreClose((decimal)Math.Cos(12.35), (decimal)values[0].Cos, 0.001m);
+        AreClose((decimal)Math.Tan(12.35), (decimal)values[0].Tan, 0.001m);
+    }
+
+    [TestMethod]
+    public void Trig_AsinAcosAtan_FloatProjection()
+    {
+        // Math.Asin / Acos / Atan emit ASIN / ACOS / ATAN. Inputs constrained
+        // to [-1, 1] for ASIN / ACOS to avoid Msg 3623.
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .Where(p => p.Id == 2)
+            .Select(p => new
+            {
+                Asin = Math.Asin((double)p.Price),
+                Acos = Math.Acos((double)p.Price),
+                Atan = Math.Atan((double)p.Price),
+            })
+            .ToArray();
+        AreClose((decimal)Math.Asin(0.5), (decimal)values[0].Asin, 0.001m);
+        AreClose((decimal)Math.Acos(0.5), (decimal)values[0].Acos, 0.001m);
+        AreClose((decimal)Math.Atan(0.5), (decimal)values[0].Atan, 0.001m);
+    }
+
+    [TestMethod]
+    public void Atan2_FloatProjection_EmitsAtn2()
+    {
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .Where(p => p.Id == 1)
+            .Select(p => Math.Atan2((double)p.Price, 1.0))
+            .ToArray();
+        AreClose((decimal)Math.Atan2(12.35, 1.0), (decimal)values[0], 0.001m);
+    }
+
     private static void AreClose(decimal expected, decimal actual, decimal tolerance)
         => Assert.IsLessThanOrEqualTo(tolerance, Math.Abs(expected - actual), $"Expected {expected} ± {tolerance}, got {actual}");
 }

SqlServerSimulator.Tests/MathScalarTrigTests.cs

@@ -0,0 +1,210 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class MathScalarTrigTests
+{
+    [TestMethod]
+    public void Sin_OfZero_ReturnsZero() => AreEqual(0.0, ExecuteScalar("select sin(cast(0 as float))"));
+
+    [TestMethod]
+    public void Cos_OfZero_ReturnsOne() => AreEqual(1.0, ExecuteScalar("select cos(cast(0 as float))"));
+
+    [TestMethod]
+    public void Tan_OfZero_ReturnsZero() => AreEqual(0.0, ExecuteScalar("select tan(cast(0 as float))"));
+
+    [TestMethod]
+    public void Asin_OfOne_ReturnsHalfPi()
+        => AreEqual(Math.PI / 2, ExecuteScalar("select asin(cast(1 as float))"));
+
+    [TestMethod]
+    public void Asin_OfNegativeOne_ReturnsNegativeHalfPi()
+        => AreEqual(-Math.PI / 2, ExecuteScalar("select asin(cast(-1 as float))"));
+
+    [TestMethod]
+    public void Acos_OfOne_ReturnsZero() => AreEqual(0.0, ExecuteScalar("select acos(cast(1 as float))"));
+
+    [TestMethod]
+    public void Acos_OfNegativeOne_ReturnsPi()
+        => AreEqual(Math.PI, ExecuteScalar("select acos(cast(-1 as float))"));
+
+    [TestMethod]
+    public void Atan_OfOne_ReturnsQuarterPi()
+        => AreEqual(Math.PI / 4, ExecuteScalar("select atan(cast(1 as float))"));
+
+    [TestMethod]
+    public void Atn2_OfOneOne_ReturnsQuarterPi()
+        => AreEqual(Math.PI / 4, ExecuteScalar("select atn2(cast(1 as float), cast(1 as float))"));
+
+    [TestMethod]
+    public void Atn2_OfZeroZero_RaisesMsg3623()
+        => AssertSqlError("select atn2(cast(0 as float), cast(0 as float))", 3623, "An invalid floating point operation occurred.");
+
+    [TestMethod]
+    public void Cot_OfOne_ReturnsCotangentOne()
+    {
+        var v = (double)ExecuteScalar("select cot(cast(1 as float))")!;
+        IsLessThan(1e-12, Math.Abs(v - (1.0 / Math.Tan(1.0))));
+    }
+
+    [TestMethod]
+    public void Cot_OfZero_RaisesMsg3623()
+        => AssertSqlError("select cot(cast(0 as float))", 3623, "An invalid floating point operation occurred.");
+
+    [TestMethod]
+    public void Pi_ReturnsPiAsFloat() => AreEqual(Math.PI, ExecuteScalar("select pi()"));
+
+    [TestMethod]
+    public void Pi_WithArgument_RaisesMsg174()
+        => AssertSqlError("select pi(1)", 174, "The pi function requires 0 argument(s).");
+
+    [TestMethod]
+    public void Sin_TooFewArgs_RaisesMsg174()
+        => AssertSqlError("select sin()", 174, "The sin function requires 1 argument(s).");
+
+    [TestMethod]
+    public void Sin_TooManyArgs_RaisesMsg174()
+        => AssertSqlError("select sin(1, 2)", 174, "The sin function requires 1 argument(s).");
+
+    [TestMethod]
+    public void Atn2_OneArg_RaisesMsg174()
+        => AssertSqlError("select atn2(1)", 174, "The atn2 function requires 2 argument(s).");
+
+    [TestMethod]
+    public void Atn2_ThreeArgs_RaisesMsg174()
+        => AssertSqlError("select atn2(1, 2, 3)", 174, "The atn2 function requires 2 argument(s).");
+
+    [TestMethod]
+    public void Asin_OutOfDomain_RaisesMsg3623()
+    {
+        AssertSqlError("select asin(cast(2 as float))", 3623, "An invalid floating point operation occurred.");
+        AssertSqlError("select asin(cast(-2 as float))", 3623, "An invalid floating point operation occurred.");
+    }
+
+    [TestMethod]
+    public void Acos_OutOfDomain_RaisesMsg3623()
+    {
+        AssertSqlError("select acos(cast(2 as float))", 3623, "An invalid floating point operation occurred.");
+        AssertSqlError("select acos(cast(-2 as float))", 3623, "An invalid floating point operation occurred.");
+    }
+
+    [TestMethod]
+    public void Sin_NullInput_PropagatesNull()
+        => AreEqual(DBNull.Value, ExecuteScalar("select sin(cast(null as float))"));
+
+    [TestMethod]
+    public void Atn2_NullFirst_PropagatesNull()
+        => AreEqual(DBNull.Value, ExecuteScalar("select atn2(cast(null as float), cast(1 as float))"));
+
+    [TestMethod]
+    public void Atn2_NullSecond_PropagatesNull()
+        => AreEqual(DBNull.Value, ExecuteScalar("select atn2(cast(1 as float), cast(null as float))"));
+
+    [TestMethod]
+    public void Sin_AcceptsAnyNumericInput()
+    {
+        AreEqual(Math.Sin(1), ExecuteScalar("select sin(cast(1 as int))"));
+        AreEqual(Math.Sin(1), ExecuteScalar("select sin(cast(1 as bigint))"));
+        AreEqual(Math.Sin(1), ExecuteScalar("select sin(cast(1 as decimal(10,2)))"));
+        AreEqual(Math.Sin(1), ExecuteScalar("select sin(cast(1 as money))"));
+    }
+
+    [TestMethod]
+    public void Square_OfTwoFloat_ReturnsFour()
+        => AreEqual(4.0, ExecuteScalar("select square(cast(2 as float))"));
+
+    [TestMethod]
+    public void Square_OfDecimal_WidensToFloat()
+        => AreEqual(12.25, ExecuteScalar("select square(cast(3.5 as decimal(10,2)))"));
+
+    [TestMethod]
+    public void Square_OfInt_WidensToFloat()
+        => AreEqual(2500000000.0, ExecuteScalar("select square(cast(50000 as int))"));
+
+    [TestMethod]
+    public void Square_Overflow_RaisesMsg8115()
+        => AssertSqlError("select square(cast(1e200 as float))", 8115, "Arithmetic overflow error converting expression to data type float.");
+
+    [TestMethod]
+    public void Degrees_OfPi_ReturnsOneHundredEighty()
+        => AreEqual(180.0, ExecuteScalar("select degrees(pi())"));
+
+    [TestMethod]
+    public void Radians_OfOneEighty_ReturnsPi()
+        => AreEqual(Math.PI, ExecuteScalar("select radians(cast(180 as float))"));
+
+    [TestMethod]
+    public void Degrees_OfInt_PreservesIntTypeAndTruncates()
+    {
+        AreEqual(57, ExecuteScalar<int>("select degrees(cast(1 as int))"));
+        AreEqual(20626, ExecuteScalar<int>("select degrees(cast(360 as int))"));
+        AreEqual(-57, ExecuteScalar<int>("select degrees(cast(-1 as int))"));
+    }
+
+    [TestMethod]
+    public void Degrees_OfBigint_PreservesBigint()
+        => AreEqual(57L, ExecuteScalar<long>("select degrees(cast(1 as bigint))"));
+
+    [TestMethod]
+    public void Degrees_IntOverflow_RaisesMsg8115Int()
+        => AssertSqlError("select degrees(cast(2147483646 as int))", 8115, "Arithmetic overflow error converting expression to data type int.");
+
+    [TestMethod]
+    public void Degrees_OfDecimal_WidensToDecimal38_18()
+    {
+        // SQL Server's decimal arithmetic uses higher-precision intermediate
+        // accumulators than .NET's 96-bit decimal, so the trailing digits
+        // diverge past the 14th decimal place. Real value: 85.94366926962348429...;
+        // simulator value: 85.94366926962348131... (matches at 13 digits).
+        var v = (decimal)ExecuteScalar("select degrees(cast(1.5 as decimal(10,2)))")!;
+        IsLessThan(1e-12m, Math.Abs(85.94366926962348m - v));
+    }
+
+    [TestMethod]
+    public void Radians_OfDecimal_WidensToDecimal38_18()
+    {
+        var v = (decimal)ExecuteScalar("select radians(cast(180 as decimal(10,2)))")!;
+        // 180 * pi / 180 = pi rendered as decimal(38, 18). Tolerance to absorb
+        // .NET-vs-SQL-Server decimal-arithmetic precision differences.
+        IsLessThan(1e-12m, Math.Abs(3.141592653589793m - v));
+    }
+
+    [TestMethod]
+    public void Degrees_PreservesScaleAboveEighteen()
+    {
+        // Input scale 22 > 18 → result decimal(38, 22). The .NET decimal storage
+        // accommodates scale 22 for small values; the encoder's Pow10(22) ≈ 1e22
+        // fits inside decimal.MaxValue (7.92e28). Larger scales (e.g. > 28)
+        // exceed .NET decimal's range entirely — that's the pre-existing
+        // 28-digit-max quirk noted in CLAUDE.md, not specific to DEGREES.
+        var v = (decimal)ExecuteScalar("select degrees(cast(0.001 as decimal(25,22)))")!;
+        var scale = (decimal.GetBits(v)[3] >> 16) & 0xFF;
+        IsLessThanOrEqualTo(22, scale);
+    }
+
+    [TestMethod]
+    public void Degrees_OfMoney_StaysMoney()
+    {
+        var v = (decimal)ExecuteScalar("select degrees(cast(1 as money))")!;
+        // money has scale 4; 1 radian in degrees ≈ 57.2958.
+        AreEqual(57.2958m, v);
+    }
+
+    [TestMethod]
+    public void Degrees_TooFewArgs_RaisesMsg174()
+        => AssertSqlError("select degrees()", 174, "The degrees function requires 1 argument(s).");
+
+    [TestMethod]
+    public void Radians_TooManyArgs_RaisesMsg174()
+        => AssertSqlError("select radians(1, 2)", 174, "The radians function requires 1 argument(s).");
+
+    [TestMethod]
+    public void Cos_OfPi_ReturnsNegativeOne()
+        => AreEqual(-1.0, ExecuteScalar("select cos(pi())"));
+
+    [TestMethod]
+    public void Square_OfNullFloat_PropagatesNull()
+        => AreEqual(DBNull.Value, ExecuteScalar("select square(cast(null as float))"));
+}

SqlServerSimulator/Parser/Expression.cs

@@ -328,22 +328,35 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
         Span<char> uppercaseName = stackalloc char[name.Length];
         return name.ToUpperInvariant(uppercaseName) switch
         {
+            2 => uppercaseName switch
+            {
+                "PI" => new Pi(context),
+                _ => null
+            },
             3 => uppercaseName switch
             {
                 "ABS" => new AbsoluteValue(context),
                 "AVG" => AggregateExpression.Parse(context, AggregateKind.Avg),
+                "COS" => new TrigFunction(context, TrigKind.Cos),
+                "COT" => new TrigFunction(context, TrigKind.Cot),
                 "EXP" => new Exp(context),
                 "IIF" => new Iif(context),
                 "LEN" => new Length(context),
                 "LOG" => new Log(context),
                 "MAX" => AggregateExpression.Parse(context, AggregateKind.Max),
                 "MIN" => AggregateExpression.Parse(context, AggregateKind.Min),
+                "SIN" => new TrigFunction(context, TrigKind.Sin),
                 "SUM" => AggregateExpression.Parse(context, AggregateKind.Sum),
+                "TAN" => new TrigFunction(context, TrigKind.Tan),
                 "VAR" => AggregateExpression.Parse(context, AggregateKind.Var),
                 _ => null
             },
             4 => uppercaseName switch
             {
+                "ACOS" => new TrigFunction(context, TrigKind.Acos),
+                "ASIN" => new TrigFunction(context, TrigKind.Asin),
+                "ATAN" => new TrigFunction(context, TrigKind.Atan),
+                "ATN2" => new Atn2(context),
                 "CAST" => new Cast(context),
                 "LEFT" => new Left(context),
                 "SIGN" => new Sign(context),
@@ -373,6 +386,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "CONCAT" => new StringConcat(context, StringConcatKind.Concat),
                 "ISNULL" => new IsNullExpression(context),
                 "NULLIF" => new NullIf(context),
+                "SQUARE" => new TrigFunction(context, TrigKind.Square),
                 "STDEVP" => AggregateExpression.Parse(context, AggregateKind.StdevP),
                 _ => null
             },
@@ -381,8 +395,10 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "CEILING" => new Ceiling(context),
                 "CONVERT" => new ConvertExpression(context, tryMode: false),
                 "DATEADD" => new DateAdd(context),
+                "DEGREES" => new Degrees(context),
                 "EOMONTH" => new EOMonth(context),
                 "GETDATE" => new CurrentTimeFunction(context, CurrentTimeKind.GetDate),
+                "RADIANS" => new Radians(context),
                 "REPLACE" => new Replace(context),
                 "REVERSE" => new Reverse(context),
                 _ => null

SqlServerSimulator/Parser/Expressions/Atn2.cs

@@ -0,0 +1,51 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// SQL <c>ATN2(y, x)</c>: returns the angle (in radians) whose tangent is
+/// <c>y / x</c>, taking the quadrant of <c>(x, y)</c> into account. Result
+/// is always <see cref="SqlType.Float"/> regardless of input categories —
+/// probe-confirmed against SQL Server 2025 (2026-05-10). NULL on either
+/// operand propagates as typed-NULL float.
+/// </summary>
+/// <remarks>
+/// SQL Server's <c>ATN2(0, 0)</c> raises Msg 3623 ("An invalid floating
+/// point operation occurred.") rather than returning 0 like .NET's
+/// <c>Math.Atan2(0, 0)</c> does — probe-confirmed.
+/// </remarks>
+internal sealed class Atn2 : Expression
+{
+    private readonly Expression first;
+    private readonly Expression second;
+
+    public Atn2(ParserContext context)
+    {
+        if (context.Token is Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.FunctionRequiresNArguments("atn2", 2);
+        this.first = Parse(context);
+        if (context.Token is not Tokens.Operator { Character: ',' })
+            throw SimulatedSqlException.FunctionRequiresNArguments("atn2", 2);
+        context.MoveNextRequired();
+        this.second = Parse(context);
+        if (context.Token is not Tokens.Operator { Character: ')' })
+            throw SimulatedSqlException.FunctionRequiresNArguments("atn2", 2);
+    }
+
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
+    {
+        var y = this.first.Run(getColumnValue);
+        if (y.IsNull) return SqlValue.Null(SqlType.Float);
+        var x = this.second.Run(getColumnValue);
+        if (x.IsNull) return SqlValue.Null(SqlType.Float);
+        var yd = MathScalars.AsDouble(y);
+        var xd = MathScalars.AsDouble(x);
+        return yd == 0 && xd == 0
+            ? throw SimulatedSqlException.InvalidFloatingPointOperation()
+            : SqlValue.FromDouble(Math.Atan2(yd, xd));
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Float;
+
+    internal override string DebugDisplay() => $"ATN2({this.first.DebugDisplay()}, {this.second.DebugDisplay()})";
+}