diff --git a/src/libraries/System.Runtime.Numerics/ref/System.Runtime.Numerics.cs b/src/libraries/System.Runtime.Numerics/ref/System.Runtime.Numerics.cs index 8abdc6b581f0f4..974d23394bf6e9 100644 --- a/src/libraries/System.Runtime.Numerics/ref/System.Runtime.Numerics.cs +++ b/src/libraries/System.Runtime.Numerics/ref/System.Runtime.Numerics.cs @@ -165,7 +165,7 @@ namespace System.Numerics public static bool TryParse([System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] string? value, out System.Numerics.BigInteger result) { throw null; } public bool TryWriteBytes(System.Span destination, out int bytesWritten, bool isUnsigned = false, bool isBigEndian = false) { throw null; } } - public readonly partial struct Complex : System.IEquatable, System.IFormattable + public readonly partial struct Complex : System.IEquatable, System.IFormattable, System.ISpanFormattable, System.Numerics.IAdditionOperators, System.Numerics.IAdditiveIdentity, System.Numerics.IDecrementOperators, System.Numerics.IDivisionOperators, System.Numerics.IEqualityOperators, System.Numerics.IIncrementOperators, System.Numerics.IMultiplicativeIdentity, System.Numerics.IMultiplyOperators, System.Numerics.INumberBase, System.Numerics.ISignedNumber, System.Numerics.ISubtractionOperators, System.Numerics.IUnaryNegationOperators, System.Numerics.IUnaryPlusOperators { private readonly int _dummyPrimitive; public static readonly System.Numerics.Complex ImaginaryOne; @@ -178,6 +178,11 @@ namespace System.Numerics public double Magnitude { get { throw null; } } public double Phase { get { throw null; } } public double Real { get { throw null; } } + static System.Numerics.Complex System.Numerics.IAdditiveIdentity.AdditiveIdentity { get { throw null; } } + static System.Numerics.Complex System.Numerics.IMultiplicativeIdentity.MultiplicativeIdentity { get { throw null; } } + static System.Numerics.Complex System.Numerics.INumberBase.One { get { throw null; } } + static System.Numerics.Complex System.Numerics.INumberBase.Zero { get { throw null; } } + static System.Numerics.Complex System.Numerics.ISignedNumber.NegativeOne { get { throw null; } } public static double Abs(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Acos(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Add(double left, System.Numerics.Complex right) { throw null; } @@ -209,6 +214,7 @@ namespace System.Numerics public static System.Numerics.Complex operator +(double left, System.Numerics.Complex right) { throw null; } public static System.Numerics.Complex operator +(System.Numerics.Complex left, double right) { throw null; } public static System.Numerics.Complex operator +(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } + public static System.Numerics.Complex operator --(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex operator /(double left, System.Numerics.Complex right) { throw null; } public static System.Numerics.Complex operator /(System.Numerics.Complex left, double right) { throw null; } public static System.Numerics.Complex operator /(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } @@ -229,6 +235,7 @@ namespace System.Numerics public static implicit operator System.Numerics.Complex (uint value) { throw null; } [System.CLSCompliantAttribute(false)] public static implicit operator System.Numerics.Complex (ulong value) { throw null; } + public static System.Numerics.Complex operator ++(System.Numerics.Complex value) { throw null; } public static bool operator !=(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } public static System.Numerics.Complex operator *(double left, System.Numerics.Complex right) { throw null; } public static System.Numerics.Complex operator *(System.Numerics.Complex left, double right) { throw null; } @@ -237,17 +244,27 @@ namespace System.Numerics public static System.Numerics.Complex operator -(System.Numerics.Complex left, double right) { throw null; } public static System.Numerics.Complex operator -(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } public static System.Numerics.Complex operator -(System.Numerics.Complex value) { throw null; } + public static System.Numerics.Complex operator +(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Pow(System.Numerics.Complex value, double power) { throw null; } public static System.Numerics.Complex Pow(System.Numerics.Complex value, System.Numerics.Complex power) { throw null; } public static System.Numerics.Complex Reciprocal(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Sin(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Sinh(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Sqrt(System.Numerics.Complex value) { throw null; } + static System.Numerics.Complex System.Numerics.IAdditionOperators.operator checked +(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } + static System.Numerics.Complex System.Numerics.IDecrementOperators.operator checked --(System.Numerics.Complex value) { throw null; } + static System.Numerics.Complex System.Numerics.IDivisionOperators.operator checked /(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } + static System.Numerics.Complex System.Numerics.IIncrementOperators.operator checked ++(System.Numerics.Complex value) { throw null; } + static System.Numerics.Complex System.Numerics.IMultiplyOperators.operator checked *(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } + static System.Numerics.Complex System.Numerics.ISubtractionOperators.operator checked -(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } + static System.Numerics.Complex System.Numerics.IUnaryNegationOperators.operator checked -(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Subtract(double left, System.Numerics.Complex right) { throw null; } public static System.Numerics.Complex Subtract(System.Numerics.Complex left, double right) { throw null; } public static System.Numerics.Complex Subtract(System.Numerics.Complex left, System.Numerics.Complex right) { throw null; } + public bool TryFormat(System.Span destination, out int charsWritten, System.ReadOnlySpan format, System.IFormatProvider? provider) { throw null; } public static System.Numerics.Complex Tan(System.Numerics.Complex value) { throw null; } public static System.Numerics.Complex Tanh(System.Numerics.Complex value) { throw null; } + public override string ToString() { throw null; } public string ToString(System.IFormatProvider? provider) { throw null; } public string ToString([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("NumericFormat")] string? format) { throw null; } diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs index 7a91d7e34aed4f..db608880506c69 100644 --- a/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs +++ b/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs @@ -3,6 +3,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; +using System.Globalization; using System.Runtime.CompilerServices; namespace System.Numerics @@ -13,7 +14,11 @@ namespace System.Numerics /// [Serializable] [TypeForwardedFrom("System.Numerics, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")] - public readonly struct Complex : IEquatable, IFormattable + public readonly struct Complex + : IEquatable, + IFormattable, + INumberBase, + ISignedNumber { public static readonly Complex Zero = new Complex(0.0, 0.0); public static readonly Complex One = new Complex(1.0, 0.0); @@ -849,5 +854,145 @@ public static explicit operator Complex(decimal value) { return new Complex((double)value, 0.0); } + + // + // IAdditionOperators + // + + /// + static Complex IAdditionOperators.operator checked +(Complex left, Complex right) => left + right; + + // + // IAdditiveIdentity + // + + /// + static Complex IAdditiveIdentity.AdditiveIdentity => new Complex(0.0, 0.0); + + // + // IDecrementOperators + // + + /// + public static Complex operator --(Complex value) => value - One; + + /// + static Complex IDecrementOperators.operator checked --(Complex value) => --value; + + // + // IDivisionOperators + // + + /// + static Complex IDivisionOperators.operator checked /(Complex left, Complex right) => left / right; + + // + // IIncrementOperators + // + + /// + public static Complex operator ++(Complex value) => value + One; + + /// + static Complex IIncrementOperators.operator checked ++(Complex value) => ++value; + + // + // IMultiplicativeIdentity + // + + /// + static Complex IMultiplicativeIdentity.MultiplicativeIdentity => new Complex(1.0, 0.0); + + // + // IMultiplyOperators + // + + /// + static Complex IMultiplyOperators.operator checked *(Complex left, Complex right) => left * right; + + // + // INumberBase + // + + /// + static Complex INumberBase.One => new Complex(1.0, 0.0); + + /// + static Complex INumberBase.Zero => new Complex(0.0, 0.0); + + // + // ISignedNumber + // + + /// + static Complex ISignedNumber.NegativeOne => new Complex(-1.0, 0.0); + + // + // ISpanFormattable + // + + /// + public bool TryFormat(Span destination, out int charsWritten, ReadOnlySpan format, IFormatProvider? provider) + { + int charsWrittenSoFar = 0; + + // We have at least 6 more characters for: (0, 0) + if (destination.Length < 6) + { + charsWritten = charsWrittenSoFar; + return false; + } + + destination[charsWrittenSoFar++] = '('; + + bool tryFormatSucceeded = m_real.TryFormat(destination.Slice(charsWrittenSoFar), out int tryFormatCharsWritten, format, provider); + charsWrittenSoFar += tryFormatCharsWritten; + + // We have at least 4 more characters for: , 0) + if (!tryFormatSucceeded || (destination.Length < (charsWrittenSoFar + 4))) + { + charsWritten = charsWrittenSoFar; + return false; + } + + destination[charsWrittenSoFar++] = ','; + destination[charsWrittenSoFar++] = ' '; + + tryFormatSucceeded = m_imaginary.TryFormat(destination.Slice(charsWrittenSoFar), out tryFormatCharsWritten, format, provider); + charsWrittenSoFar += tryFormatCharsWritten; + + // We have at least 1 more character for: ) + if (!tryFormatSucceeded || (destination.Length < (charsWrittenSoFar + 1))) + { + charsWritten = charsWrittenSoFar; + return false; + } + + destination[charsWrittenSoFar++] = ')'; + + charsWritten = charsWrittenSoFar; + return true; + } + + // + // ISubtractionOperators + // + + /// + static Complex ISubtractionOperators.operator checked -(Complex left, Complex right) => left - right; + + // + // IUnaryNegationOperators + // + + /// + static Complex IUnaryNegationOperators.operator checked -(Complex value) => -value; + + // + // IUnaryPlusOperators + // + + /// + public static Complex operator +(Complex value) => value; } } diff --git a/src/libraries/System.Runtime.Numerics/tests/ComplexTests.GenericMath.cs b/src/libraries/System.Runtime.Numerics/tests/ComplexTests.GenericMath.cs new file mode 100644 index 00000000000000..6ed1401fb94c21 --- /dev/null +++ b/src/libraries/System.Runtime.Numerics/tests/ComplexTests.GenericMath.cs @@ -0,0 +1,306 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Xunit; + +namespace System.Numerics.Tests +{ + public class ComplexTests_GenericMath + { + private static Complex MinNormal => 2.2250738585072014E-308; + + private static Complex MaxSubnormal => 2.2250738585072009E-308; + + private static void AssertBitwiseEqual(double expected, double actual) + { + ulong expectedBits = BitConverter.DoubleToUInt64Bits(expected); + ulong actualBits = BitConverter.DoubleToUInt64Bits(actual); + + if (expectedBits == actualBits) + { + return; + } + + if (Complex.IsNaN(expected) && Complex.IsNaN(actual)) + { + return; + } + + throw new Xunit.Sdk.EqualException(expected, actual); + } + + private static void AssertBitwiseEqual(Complex expected, Complex actual) + { + AssertBitwiseEqual(expected.Real, actual.Real); + AssertBitwiseEqual(expected.Imaginary, actual.Imaginary); + } + + [Fact] + public static void AdditiveIdentityTest() + { + AssertBitwiseEqual(0.0, AdditiveIdentityHelper.AdditiveIdentity); + } + + [Fact] + public static void MultiplicativeIdentityTest() + { + AssertBitwiseEqual(1.0, MultiplicativeIdentityHelper.MultiplicativeIdentity); + } + + [Fact] + public static void NegativeOneTest() + { + Assert.Equal(-1.0, SignedNumberHelper.NegativeOne); + } + + [Fact] + public static void OneTest() + { + AssertBitwiseEqual(1.0, NumberBaseHelper.One); + } + + [Fact] + public static void ZeroTest() + { + AssertBitwiseEqual(0.0, NumberBaseHelper.Zero); + } + + [Fact] + public static void op_AdditionTest() + { + AssertBitwiseEqual(0.0, AdditionOperatorsHelper.op_Addition(-1.0, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_Addition(-MinNormal, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_Addition(-MaxSubnormal, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_Addition(-0.0, 1.0)); + AssertBitwiseEqual(Complex.NaN, AdditionOperatorsHelper.op_Addition(Complex.NaN, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_Addition(0.0, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_Addition(MaxSubnormal, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_Addition(MinNormal, 1.0)); + AssertBitwiseEqual(2.0, AdditionOperatorsHelper.op_Addition(1.0, 1.0)); + } + + [Fact] + public static void op_CheckedAdditionTest() + { + AssertBitwiseEqual(0.0, AdditionOperatorsHelper.op_CheckedAddition(-1.0, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_CheckedAddition(-MinNormal, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_CheckedAddition(-MaxSubnormal, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_CheckedAddition(-0.0, 1.0)); + AssertBitwiseEqual(Complex.NaN, AdditionOperatorsHelper.op_CheckedAddition(Complex.NaN, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_CheckedAddition(0.0, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_CheckedAddition(MaxSubnormal, 1.0)); + AssertBitwiseEqual(1.0, AdditionOperatorsHelper.op_CheckedAddition(MinNormal, 1.0)); + AssertBitwiseEqual(2.0, AdditionOperatorsHelper.op_CheckedAddition(1.0, 1.0)); + } + + [Fact] + public static void op_DecrementTest() + { + AssertBitwiseEqual(-2.0, DecrementOperatorsHelper.op_Decrement(-1.0)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), DecrementOperatorsHelper.op_Decrement(-MinNormal)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), DecrementOperatorsHelper.op_Decrement(-MaxSubnormal)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_Decrement(-0.0)); + AssertBitwiseEqual(Complex.NaN, DecrementOperatorsHelper.op_Decrement(Complex.NaN)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_Decrement(0.0)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_Decrement(MaxSubnormal)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_Decrement(MinNormal)); + AssertBitwiseEqual(0.0, DecrementOperatorsHelper.op_Decrement(1.0)); + } + + [Fact] + public static void op_CheckedDecrementTest() + { + AssertBitwiseEqual(-2.0, DecrementOperatorsHelper.op_CheckedDecrement(-1.0)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), DecrementOperatorsHelper.op_CheckedDecrement(-MinNormal)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), DecrementOperatorsHelper.op_CheckedDecrement(-MaxSubnormal)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_CheckedDecrement(-0.0)); + AssertBitwiseEqual(Complex.NaN, DecrementOperatorsHelper.op_CheckedDecrement(Complex.NaN)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_CheckedDecrement(0.0)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_CheckedDecrement(MaxSubnormal)); + AssertBitwiseEqual(-1.0, DecrementOperatorsHelper.op_CheckedDecrement(MinNormal)); + AssertBitwiseEqual(0.0, DecrementOperatorsHelper.op_CheckedDecrement(1.0)); + } + + [Fact] + public static void op_DivisionTest() + { + AssertBitwiseEqual(-0.5, DivisionOperatorsHelper.op_Division(-1.0, 2.0)); + AssertBitwiseEqual(-1.1125369292536007E-308, DivisionOperatorsHelper.op_Division(-MinNormal, 2.0)); + AssertBitwiseEqual(-1.1125369292536007E-308, DivisionOperatorsHelper.op_Division(-MaxSubnormal, 2.0)); + AssertBitwiseEqual(0.0, DivisionOperatorsHelper.op_Division(-0.0, 2.0)); + AssertBitwiseEqual(Complex.NaN, DivisionOperatorsHelper.op_Division(Complex.NaN, 2.0)); + AssertBitwiseEqual(0.0, DivisionOperatorsHelper.op_Division(0.0, 2.0)); + AssertBitwiseEqual(1.1125369292536007E-308, DivisionOperatorsHelper.op_Division(MaxSubnormal, 2.0)); + AssertBitwiseEqual(1.1125369292536007E-308, DivisionOperatorsHelper.op_Division(MinNormal, 2.0)); + AssertBitwiseEqual(0.5, DivisionOperatorsHelper.op_Division(1.0, 2.0)); + } + + [Fact] + public static void op_CheckedDivisionTest() + { + AssertBitwiseEqual(-0.5, DivisionOperatorsHelper.op_CheckedDivision(-1.0, 2.0)); + AssertBitwiseEqual(-1.1125369292536007E-308, DivisionOperatorsHelper.op_CheckedDivision(-MinNormal, 2.0)); + AssertBitwiseEqual(-1.1125369292536007E-308, DivisionOperatorsHelper.op_CheckedDivision(-MaxSubnormal, 2.0)); + AssertBitwiseEqual(0.0, DivisionOperatorsHelper.op_CheckedDivision(-0.0, 2.0)); + AssertBitwiseEqual(Complex.NaN, DivisionOperatorsHelper.op_CheckedDivision(Complex.NaN, 2.0)); + AssertBitwiseEqual(0.0, DivisionOperatorsHelper.op_CheckedDivision(0.0, 2.0)); + AssertBitwiseEqual(1.1125369292536007E-308, DivisionOperatorsHelper.op_CheckedDivision(MaxSubnormal, 2.0)); + AssertBitwiseEqual(1.1125369292536007E-308, DivisionOperatorsHelper.op_CheckedDivision(MinNormal, 2.0)); + AssertBitwiseEqual(0.5, DivisionOperatorsHelper.op_CheckedDivision(1.0, 2.0)); + } + + [Fact] + public static void op_EqualityTest() + { + Assert.False(EqualityOperatorsHelper.op_Equality(-1.0, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(-MinNormal, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(-MaxSubnormal, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(-0.0, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(Complex.NaN, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(0.0, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(MaxSubnormal, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Equality(MinNormal, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Equality(1.0, 1.0)); + } + + [Fact] + public static void op_InequalityTest() + { + Assert.True(EqualityOperatorsHelper.op_Inequality(-1.0, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(-MinNormal, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(-MaxSubnormal, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(-0.0, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(Complex.NaN, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(0.0, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(MaxSubnormal, 1.0)); + Assert.True(EqualityOperatorsHelper.op_Inequality(MinNormal, 1.0)); + Assert.False(EqualityOperatorsHelper.op_Inequality(1.0, 1.0)); + } + + [Fact] + public static void op_IncrementTest() + { + AssertBitwiseEqual(0.0, IncrementOperatorsHelper.op_Increment(-1.0)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_Increment(-MinNormal)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_Increment(-MaxSubnormal)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_Increment(-0.0)); + AssertBitwiseEqual(Complex.NaN, IncrementOperatorsHelper.op_Increment(Complex.NaN)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_Increment(0.0)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_Increment(MaxSubnormal)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_Increment(MinNormal)); + AssertBitwiseEqual(2.0, IncrementOperatorsHelper.op_Increment(1.0)); + } + + [Fact] + public static void op_CheckedIncrementTest() + { + AssertBitwiseEqual(0.0, IncrementOperatorsHelper.op_CheckedIncrement(-1.0)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_CheckedIncrement(-MinNormal)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_CheckedIncrement(-MaxSubnormal)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_CheckedIncrement(-0.0)); + AssertBitwiseEqual(Complex.NaN, IncrementOperatorsHelper.op_CheckedIncrement(Complex.NaN)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_CheckedIncrement(0.0)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_CheckedIncrement(MaxSubnormal)); + AssertBitwiseEqual(1.0, IncrementOperatorsHelper.op_CheckedIncrement(MinNormal)); + AssertBitwiseEqual(2.0, IncrementOperatorsHelper.op_CheckedIncrement(1.0)); + } + + [Fact] + public static void op_MultiplyTest() + { + AssertBitwiseEqual(-2.0, MultiplyOperatorsHelper.op_Multiply(-1.0, 2.0)); + AssertBitwiseEqual(new Complex(-4.4501477170144028E-308, -0.0), MultiplyOperatorsHelper.op_Multiply(-MinNormal, 2.0)); + AssertBitwiseEqual(new Complex(-4.4501477170144018E-308, -0.0), MultiplyOperatorsHelper.op_Multiply(-MaxSubnormal, 2.0)); + AssertBitwiseEqual(-0.0, MultiplyOperatorsHelper.op_Multiply(-0.0, 2.0)); + AssertBitwiseEqual(Complex.NaN, MultiplyOperatorsHelper.op_Multiply(Complex.NaN, 2.0)); + AssertBitwiseEqual(0.0, MultiplyOperatorsHelper.op_Multiply(0.0, 2.0)); + AssertBitwiseEqual(4.4501477170144018E-308, MultiplyOperatorsHelper.op_Multiply(MaxSubnormal, 2.0)); + AssertBitwiseEqual(4.4501477170144028E-308, MultiplyOperatorsHelper.op_Multiply(MinNormal, 2.0)); + AssertBitwiseEqual(2.0, MultiplyOperatorsHelper.op_Multiply(1.0, 2.0)); + } + + [Fact] + public static void op_CheckedMultiplyTest() + { + AssertBitwiseEqual(-2.0, MultiplyOperatorsHelper.op_CheckedMultiply(-1.0, 2.0)); + AssertBitwiseEqual(new Complex(-4.4501477170144028E-308, -0.0), MultiplyOperatorsHelper.op_CheckedMultiply(-MinNormal, 2.0)); + AssertBitwiseEqual(new Complex(-4.4501477170144018E-308, -0.0), MultiplyOperatorsHelper.op_CheckedMultiply(-MaxSubnormal, 2.0)); + AssertBitwiseEqual(-0.0, MultiplyOperatorsHelper.op_CheckedMultiply(-0.0, 2.0)); + AssertBitwiseEqual(Complex.NaN, MultiplyOperatorsHelper.op_CheckedMultiply(Complex.NaN, 2.0)); + AssertBitwiseEqual(0.0, MultiplyOperatorsHelper.op_CheckedMultiply(0.0, 2.0)); + AssertBitwiseEqual(4.4501477170144018E-308, MultiplyOperatorsHelper.op_CheckedMultiply(MaxSubnormal, 2.0)); + AssertBitwiseEqual(4.4501477170144028E-308, MultiplyOperatorsHelper.op_CheckedMultiply(MinNormal, 2.0)); + AssertBitwiseEqual(2.0, MultiplyOperatorsHelper.op_CheckedMultiply(1.0, 2.0)); + } + + [Fact] + public static void op_SubtractionTest() + { + AssertBitwiseEqual(-2.0, SubtractionOperatorsHelper.op_Subtraction(-1.0, 1.0)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), SubtractionOperatorsHelper.op_Subtraction(-MinNormal, 1.0)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), SubtractionOperatorsHelper.op_Subtraction(-MaxSubnormal, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_Subtraction(-0.0, 1.0)); + AssertBitwiseEqual(Complex.NaN, SubtractionOperatorsHelper.op_Subtraction(Complex.NaN, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_Subtraction(0.0, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_Subtraction(MaxSubnormal, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_Subtraction(MinNormal, 1.0)); + AssertBitwiseEqual(0.0, SubtractionOperatorsHelper.op_Subtraction(1.0, 1.0)); + } + + [Fact] + public static void op_CheckedSubtractionTest() + { + AssertBitwiseEqual(-2.0, SubtractionOperatorsHelper.op_CheckedSubtraction(-1.0, 1.0)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), SubtractionOperatorsHelper.op_CheckedSubtraction(-MinNormal, 1.0)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), SubtractionOperatorsHelper.op_CheckedSubtraction(-MaxSubnormal, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_CheckedSubtraction(-0.0, 1.0)); + AssertBitwiseEqual(Complex.NaN, SubtractionOperatorsHelper.op_CheckedSubtraction(Complex.NaN, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_CheckedSubtraction(0.0, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_CheckedSubtraction(MaxSubnormal, 1.0)); + AssertBitwiseEqual(-1.0, SubtractionOperatorsHelper.op_CheckedSubtraction(MinNormal, 1.0)); + AssertBitwiseEqual(0.0, SubtractionOperatorsHelper.op_CheckedSubtraction(1.0, 1.0)); + } + + [Fact] + public static void op_UnaryNegationTest() + { + AssertBitwiseEqual(new Complex(1.0, -0.0), UnaryNegationOperatorsHelper.op_UnaryNegation(-1.0)); + AssertBitwiseEqual(MinNormal, UnaryNegationOperatorsHelper.op_UnaryNegation(-MinNormal)); + AssertBitwiseEqual(MaxSubnormal, UnaryNegationOperatorsHelper.op_UnaryNegation(-MaxSubnormal)); + AssertBitwiseEqual(new Complex(0.0, -0.0), UnaryNegationOperatorsHelper.op_UnaryNegation(-0.0)); + AssertBitwiseEqual(Complex.NaN, UnaryNegationOperatorsHelper.op_UnaryNegation(Complex.NaN)); + AssertBitwiseEqual(new Complex(-0.0, -0.0), UnaryNegationOperatorsHelper.op_UnaryNegation(0.0)); + AssertBitwiseEqual(-MaxSubnormal, UnaryNegationOperatorsHelper.op_UnaryNegation(MaxSubnormal)); + AssertBitwiseEqual(-MinNormal, UnaryNegationOperatorsHelper.op_UnaryNegation(MinNormal)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), UnaryNegationOperatorsHelper.op_UnaryNegation(1.0)); + } + + [Fact] + public static void op_CheckedUnaryNegationTest() + { + AssertBitwiseEqual(new Complex(1.0, -0.0), UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(-1.0)); + AssertBitwiseEqual(MinNormal, UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(-MinNormal)); + AssertBitwiseEqual(MaxSubnormal, UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(-MaxSubnormal)); + AssertBitwiseEqual(new Complex(0.0, -0.0), UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(-0.0)); + AssertBitwiseEqual(Complex.NaN, UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(Complex.NaN)); + AssertBitwiseEqual(new Complex(-0.0, -0.0), UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(0.0)); + AssertBitwiseEqual(-MaxSubnormal, UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(MaxSubnormal)); + AssertBitwiseEqual(-MinNormal, UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(MinNormal)); + AssertBitwiseEqual(new Complex(-1.0, -0.0), UnaryNegationOperatorsHelper.op_CheckedUnaryNegation(1.0)); + } + + [Fact] + public static void op_UnaryPlusTest() + { + AssertBitwiseEqual(-1.0, UnaryPlusOperatorsHelper.op_UnaryPlus(-1.0)); + AssertBitwiseEqual(-MinNormal, UnaryPlusOperatorsHelper.op_UnaryPlus(-MinNormal)); + AssertBitwiseEqual(-MaxSubnormal, UnaryPlusOperatorsHelper.op_UnaryPlus(-MaxSubnormal)); + AssertBitwiseEqual(-0.0, UnaryPlusOperatorsHelper.op_UnaryPlus(-0.0)); + AssertBitwiseEqual(Complex.NaN, UnaryPlusOperatorsHelper.op_UnaryPlus(Complex.NaN)); + AssertBitwiseEqual(0.0, UnaryPlusOperatorsHelper.op_UnaryPlus(0.0)); + AssertBitwiseEqual(MaxSubnormal, UnaryPlusOperatorsHelper.op_UnaryPlus(MaxSubnormal)); + AssertBitwiseEqual(MinNormal, UnaryPlusOperatorsHelper.op_UnaryPlus(MinNormal)); + AssertBitwiseEqual(1.0, UnaryPlusOperatorsHelper.op_UnaryPlus(1.0)); + } + } +} diff --git a/src/libraries/System.Runtime.Numerics/tests/System.Runtime.Numerics.Tests.csproj b/src/libraries/System.Runtime.Numerics/tests/System.Runtime.Numerics.Tests.csproj index 4b9dbea05bf6b0..b5ca26db0ee0ca 100644 --- a/src/libraries/System.Runtime.Numerics/tests/System.Runtime.Numerics.Tests.csproj +++ b/src/libraries/System.Runtime.Numerics/tests/System.Runtime.Numerics.Tests.csproj @@ -1,4 +1,4 @@ - + $(NetCoreAppCurrent) true @@ -54,6 +54,10 @@ + + + +