Merge branch 'develop' into main

.github/workflows/dotnet.yml

@@ -2,9 +2,13 @@ name: .NET
 
 on:
   push:
-    branches: [ main ]
+    branches:
+      - main
+      - develop
   pull_request:
-    branches: [ main ]
+    branches:
+      - main
+      - develop
 
 jobs:
   build:

CHANGELOG.md

@@ -5,7 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## 3.2.0 - [Unreleased]
+## 4.0.0 - [Unreleased]
+
+### Added
+- X10D: Added extension methods for `DateOnly`, for parity with `DateTime` and `DateTimeOffset`.
+- X10D: Added math-related extension methods for `BigInteger`.
+
+### Changed
+- X10D: `DateTime.Age(DateTime)` and `DateTimeOffset.Age(DateTimeOffset)` parameter renamed from `asOf` to `referenceDate`.
+
+## [3.2.0] - 2023-04-03
 
 ### Added
 
@@ -567,7 +576,8 @@ please [open an issue](https://github.com/oliverbooth/X10D/issues)!
 
 Earlier versions of this package are undocumented and unlisted from package results.
 
-[unreleased]: https://github.com/oliverbooth/X10D/compare/v3.1.0...develop
+[unreleased]: https://github.com/oliverbooth/X10D/compare/v3.2.0...main
+[3.2.0]: https://github.com/oliverbooth/X10D/releases/tag/v3.2.0
 [3.1.0]: https://github.com/oliverbooth/X10D/releases/tag/v3.1.0
 [3.0.0]: https://github.com/oliverbooth/X10D/releases/tag/v3.0.0
 [2.6.0]: https://github.com/oliverbooth/X10D/releases/tag/2.6.0

X10D.DSharpPlus/X10D.DSharpPlus.csproj

@@ -16,7 +16,7 @@
         <PackageTags>dotnet extension-methods</PackageTags>
         <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/../CHANGELOG.md"))</PackageReleaseNotes>
         <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
-        <VersionPrefix>3.2.0</VersionPrefix>
+        <VersionPrefix>4.0.0</VersionPrefix>
         <Nullable>enable</Nullable>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>

X10D.Hosting/X10D.Hosting.csproj

@@ -16,7 +16,7 @@
         <PackageTags>dotnet extension-methods</PackageTags>
         <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/../CHANGELOG.md"))</PackageReleaseNotes>
         <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
-        <VersionPrefix>3.2.0</VersionPrefix>
+        <VersionPrefix>4.0.0</VersionPrefix>
         <Nullable>enable</Nullable>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>

X10D.Tests/src/Math/BigIntegerTests.Wrap.cs

@@ -0,0 +1,105 @@
+using System.Numerics;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Math;
+
+namespace X10D.Tests.Math;
+
+public partial class BigIntegerTests
+{
+    [TestClass]
+    public class WrapTests
+    {
+        [TestMethod]
+        public void Wrap_ShouldReturnLow_WhenValueIsEqualToLow()
+        {
+            BigInteger value = 10;
+            BigInteger low = 10;
+            BigInteger high = 20;
+
+            BigInteger result = value.Wrap(low, high);
+
+            Assert.AreEqual(low, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnHigh_WhenValueIsEqualToHigh()
+        {
+            BigInteger value = 20;
+            BigInteger low = 10;
+            BigInteger high = 20;
+
+            BigInteger result = value.Wrap(low, high);
+
+            Assert.AreEqual(low, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnCorrectResult_WhenValueIsGreaterThanHigh()
+        {
+            BigInteger value = 30;
+            BigInteger low = 10;
+            BigInteger high = 20;
+
+            BigInteger result = value.Wrap(low, high);
+
+            Assert.AreEqual(low, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnCorrectResult_WhenValueIsLessThanLow()
+        {
+            BigInteger value = 5;
+            BigInteger low = 10;
+            BigInteger high = 20;
+
+            BigInteger result = value.Wrap(low, high);
+
+            Assert.AreEqual(15L, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnCorrectResult_WhenValueIsInBetweenLowAndHigh()
+        {
+            BigInteger value = 15;
+            BigInteger low = 10;
+            BigInteger high = 20;
+
+            BigInteger result = value.Wrap(low, high);
+
+            Assert.AreEqual(value, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnZero_WhenValueIsEqualToLength()
+        {
+            BigInteger value = 10;
+            BigInteger length = 10;
+
+            BigInteger result = value.Wrap(length);
+
+            Assert.AreEqual(0L, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnValue_WhenValueIsLessThanLength()
+        {
+            BigInteger value = 5;
+            BigInteger length = 10;
+
+            BigInteger result = value.Wrap(length);
+
+            Assert.AreEqual(value, result);
+        }
+
+        [TestMethod]
+        public void Wrap_ShouldReturnCorrectResult_WhenValueIsGreaterThanLength()
+        {
+            BigInteger value = 15;
+            BigInteger length = 10;
+
+            BigInteger result = value.Wrap(length);
+
+            Assert.AreEqual(5L, result);
+        }
+    }
+}

X10D.Tests/src/Math/BigIntegerTests.cs

@@ -0,0 +1,159 @@
+using System.Numerics;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Math;
+
+namespace X10D.Tests.Math;
+
+[TestClass]
+public partial class BigIntegerTests
+{
+    [TestMethod]
+    public void DigitalRootShouldBeCorrect()
+    {
+        BigInteger value = 238;
+        Assert.AreEqual(4, value.DigitalRoot());
+        Assert.AreEqual(4, (-value).DigitalRoot());
+    }
+
+    [TestMethod]
+    public void FactorialShouldBeCorrect()
+    {
+        Assert.AreEqual(1, ((BigInteger)0).Factorial());
+        Assert.AreEqual(1, ((BigInteger)1).Factorial());
+        Assert.AreEqual(2, ((BigInteger)2).Factorial());
+        Assert.AreEqual(6, ((BigInteger)3).Factorial());
+        Assert.AreEqual(24, ((BigInteger)4).Factorial());
+        Assert.AreEqual(120, ((BigInteger)5).Factorial());
+        Assert.AreEqual(720, ((BigInteger)6).Factorial());
+        Assert.AreEqual(5040, ((BigInteger)7).Factorial());
+        Assert.AreEqual(40320, ((BigInteger)8).Factorial());
+        Assert.AreEqual(362880, ((BigInteger)9).Factorial());
+        Assert.AreEqual(3628800, ((BigInteger)10).Factorial());
+    }
+
+    [TestMethod]
+    public void GreatestCommonFactor_ShouldBe1_ForPrimeNumbers()
+    {
+        BigInteger first = 5L;
+        BigInteger second = 7L;
+
+        BigInteger multiple = first.GreatestCommonFactor(second);
+
+        Assert.AreEqual(1L, multiple);
+    }
+
+    [TestMethod]
+    public void GreatestCommonFactor_ShouldBe6_Given12And18()
+    {
+        BigInteger first = 12L;
+        BigInteger second = 18L;
+
+        BigInteger multiple = first.GreatestCommonFactor(second);
+
+        Assert.AreEqual(6L, multiple);
+    }
+
+    [TestMethod]
+    public void IsOddShouldBeCorrect()
+    {
+        BigInteger one = 1;
+        BigInteger two = 2;
+
+        Assert.IsTrue(one.IsOdd());
+        Assert.IsFalse(two.IsOdd());
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithValidInput()
+    {
+        BigInteger value1 = 2;
+        BigInteger value2 = 3;
+        BigInteger expected = 6;
+
+        BigInteger result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnZero_WhenCalledWithZero()
+    {
+        BigInteger value1 = 0;
+        BigInteger value2 = 10;
+        BigInteger expected = 0;
+
+        BigInteger result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnGreaterValue_WhenCalledWithOne()
+    {
+        BigInteger value1 = 1;
+        BigInteger value2 = 10;
+        BigInteger expected = 10;
+
+        BigInteger result1 = value1.LowestCommonMultiple(value2);
+        BigInteger result2 = value2.LowestCommonMultiple(value1);
+
+        Assert.AreEqual(expected, result1);
+        Assert.AreEqual(expected, result2);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnOtherValue_WhenCalledWithSameValue()
+    {
+        BigInteger value1 = 5;
+        BigInteger value2 = 5;
+        BigInteger expected = 5;
+
+        BigInteger result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void LowestCommonMultiple_ShouldReturnCorrectValue_WhenCalledWithNegativeValues()
+    {
+        BigInteger value1 = -2;
+        BigInteger value2 = 3;
+        BigInteger expected = -6;
+
+        BigInteger result = value1.LowestCommonMultiple(value2);
+
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void MultiplicativePersistence_ShouldReturn1_ForAnyDigitBeing0()
+    {
+        Assert.AreEqual(1, ((BigInteger)10).MultiplicativePersistence());
+        Assert.AreEqual(1, ((BigInteger)201).MultiplicativePersistence());
+        Assert.AreEqual(1, ((BigInteger)200).MultiplicativePersistence());
+        Assert.AreEqual(1, ((BigInteger)20007).MultiplicativePersistence());
+    }
+
+    [TestMethod]
+    public void MultiplicativePersistence_ShouldBeCorrect_ForRecordHolders()
+    {
+        Assert.AreEqual(0, ((BigInteger)0).MultiplicativePersistence());
+        Assert.AreEqual(1, ((BigInteger)10).MultiplicativePersistence());
+        Assert.AreEqual(2, ((BigInteger)25).MultiplicativePersistence());
+        Assert.AreEqual(3, ((BigInteger)39).MultiplicativePersistence());
+        Assert.AreEqual(4, ((BigInteger)77).MultiplicativePersistence());
+        Assert.AreEqual(5, ((BigInteger)679).MultiplicativePersistence());
+        Assert.AreEqual(6, ((BigInteger)6788).MultiplicativePersistence());
+        Assert.AreEqual(7, ((BigInteger)68889).MultiplicativePersistence());
+        Assert.AreEqual(8, ((BigInteger)2677889).MultiplicativePersistence());
+        Assert.AreEqual(9, ((BigInteger)26888999).MultiplicativePersistence());
+        Assert.AreEqual(10, ((BigInteger)3778888999).MultiplicativePersistence());
+        Assert.AreEqual(11, ((BigInteger)277777788888899).MultiplicativePersistence());
+    }
+
+    [TestMethod]
+    public void NegativeFactorialShouldThrow()
+    {
+        Assert.ThrowsException<ArithmeticException>(() => ((BigInteger)(-1)).Factorial());
+    }
+}

X10D.Tests/src/Math/IsPrimeTests.cs

@@ -1,4 +1,5 @@
-using System.Reflection;
+using System.Numerics;
+using System.Reflection;
 using System.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using X10D.Math;
@@ -26,6 +27,7 @@ public class IsPrimeTests
 
             Assert.IsTrue(value.IsPrime());
             Assert.IsTrue(((long)value).IsPrime());
+            Assert.IsTrue(((BigInteger)value).IsPrime());
 
             if (value is >= byte.MinValue and <= byte.MaxValue)
             {
@@ -68,6 +70,7 @@ public class IsPrimeTests
             Assert.IsFalse(value.IsPrime());
             Assert.IsFalse(((int)value).IsPrime());
             Assert.IsFalse(((long)value).IsPrime());
+            Assert.IsFalse(((BigInteger)value).IsPrime());
 
             if (value is >= sbyte.MinValue and <= sbyte.MaxValue)
             {
@@ -85,6 +88,7 @@ public class IsPrimeTests
             Assert.IsFalse(((byte)value).IsPrime());
             Assert.IsFalse(((short)value).IsPrime());
             Assert.IsFalse(((long)value).IsPrime());
+            Assert.IsFalse(((BigInteger)value).IsPrime());
 
             Assert.IsFalse(((sbyte)value).IsPrime());
             Assert.IsFalse(((ushort)value).IsPrime());
@@ -103,6 +107,7 @@ public class IsPrimeTests
             Assert.AreEqual(expected, ((short)value).IsPrime());
             Assert.AreEqual(expected, value.IsPrime());
             Assert.AreEqual(expected, ((long)value).IsPrime());
+            Assert.AreEqual(expected, ((BigInteger)value).IsPrime());
 
             Assert.AreEqual(expected, ((ushort)value).IsPrime());
             Assert.AreEqual(expected, ((uint)value).IsPrime());
@@ -121,6 +126,7 @@ public class IsPrimeTests
             Assert.AreEqual(expected, ((short)value).IsPrime());
             Assert.AreEqual(expected, ((int)value).IsPrime());
             Assert.AreEqual(expected, ((long)value).IsPrime());
+            Assert.AreEqual(expected, ((BigInteger)value).IsPrime());
 
             Assert.AreEqual(expected, ((ushort)value).IsPrime());
             Assert.AreEqual(expected, ((uint)value).IsPrime());

X10D.Tests/src/Time/DateOnlyTests.cs

@@ -0,0 +1,230 @@
+#if NET6_0_OR_GREATER
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using X10D.Time;
+
+namespace X10D.Tests.Time;
+
+[TestClass]
+public class DateOnlyTests
+{
+    [TestMethod]
+    public void Age_ShouldBe17_Given31December1991Birthday_And30December2017Date()
+    {
+        var reference = new DateOnly(2017, 12, 30);
+        var birthday = new DateOnly(1999, 12, 31);
+
+        int age = birthday.Age(reference);
+
+        Assert.AreEqual(17, age);
+    }
+
+    [TestMethod]
+    public void Age_ShouldBe18_Given31December1991Birthday_And1January2018Date()
+    {
+        var reference = new DateOnly(2018, 1, 1);
+        var birthday = new DateOnly(1999, 12, 31);
+
+        int age = birthday.Age(reference);
+
+        Assert.AreEqual(18, age);
+    }
+
+    [TestMethod]
+    public void Age_ShouldBe18_Given31December1991Birthday_And31December2017Date()
+    {
+        var reference = new DateOnly(2017, 12, 31);
+        var birthday = new DateOnly(1999, 12, 31);
+
+        int age = birthday.Age(reference);
+
+        Assert.AreEqual(18, age);
+    }
+
+    [TestMethod]
+    public void Deconstruct_ShouldDeconstructToTuple_GivenDateOnly()
+    {
+        var date = new DateOnly(2017, 12, 31);
+
+        (int year, int month, int day) = date;
+
+        Assert.AreEqual(2017, year);
+        Assert.AreEqual(12, month);
+        Assert.AreEqual(31, day);
+    }
+
+    [TestMethod]
+    public void First_ShouldBeSaturday_Given1Jan2000()
+    {
+        var date = new DateOnly(2000, 1, 1);
+
+        Assert.AreEqual(new DateOnly(2000, 1, 1), date.First(DayOfWeek.Saturday));
+        Assert.AreEqual(new DateOnly(2000, 1, 2), date.First(DayOfWeek.Sunday));
+        Assert.AreEqual(new DateOnly(2000, 1, 3), date.First(DayOfWeek.Monday));
+        Assert.AreEqual(new DateOnly(2000, 1, 4), date.First(DayOfWeek.Tuesday));
+        Assert.AreEqual(new DateOnly(2000, 1, 5), date.First(DayOfWeek.Wednesday));
+        Assert.AreEqual(new DateOnly(2000, 1, 6), date.First(DayOfWeek.Thursday));
+        Assert.AreEqual(new DateOnly(2000, 1, 7), date.First(DayOfWeek.Friday));
+    }
+
+    [TestMethod]
+    public void FirstDayOfMonth_ShouldBe1st_GivenToday()
+    {
+        DateOnly today = DateOnly.FromDateTime(DateTime.Now.Date);
+
+        Assert.AreEqual(new DateOnly(today.Year, today.Month, 1), today.FirstDayOfMonth());
+    }
+
+    [TestMethod]
+    public void GetIso8601WeekOfYear_ShouldReturn1_Given4January1970()
+    {
+        var date = new DateOnly(1970, 1, 4);
+        int iso8601WeekOfYear = date.GetIso8601WeekOfYear();
+
+        Assert.AreEqual(1, iso8601WeekOfYear);
+    }
+
+    [TestMethod]
+    public void GetIso8601WeekOfYear_ShouldReturn1_Given31December1969()
+    {
+        var date = new DateOnly(1969, 12, 31);
+        int iso8601WeekOfYear = date.GetIso8601WeekOfYear();
+
+        Assert.AreEqual(1, iso8601WeekOfYear);
+    }
+
+    [TestMethod]
+    public void GetIso8601WeekOfYear_ShouldReturn53_Given31December1970()
+    {
+        var date = new DateOnly(1970, 12, 31);
+        int iso8601WeekOfYear = date.GetIso8601WeekOfYear();
+
+        Assert.AreEqual(53, iso8601WeekOfYear);
+    }
+
+    [TestMethod]
+    public void IsLeapYear_ShouldBeFalse_Given1999()
+    {
+        var date = new DateOnly(1999, 1, 1);
+        Assert.IsFalse(date.IsLeapYear());
+    }
+
+    [TestMethod]
+    public void IsLeapYear_ShouldBeTrue_Given2000()
+    {
+        var date = new DateOnly(2000, 1, 1);
+        Assert.IsTrue(date.IsLeapYear());
+    }
+
+    [TestMethod]
+    public void IsLeapYear_ShouldBeFalse_Given2001()
+    {
+        var date = new DateOnly(2001, 1, 1);
+        Assert.IsFalse(date.IsLeapYear());
+    }
+
+    [TestMethod]
+    public void IsLeapYear_ShouldBeFalse_Given2100()
+    {
+        var date = new DateOnly(2100, 1, 1);
+        Assert.IsFalse(date.IsLeapYear());
+    }
+
+    [TestMethod]
+    public void LastSaturday_ShouldBe29th_Given1Jan2000()
+    {
+        var date = new DateOnly(2000, 1, 1);
+
+        Assert.AreEqual(new DateOnly(2000, 1, 29), date.Last(DayOfWeek.Saturday));
+        Assert.AreEqual(new DateOnly(2000, 1, 30), date.Last(DayOfWeek.Sunday));
+        Assert.AreEqual(new DateOnly(2000, 1, 31), date.Last(DayOfWeek.Monday));
+        Assert.AreEqual(new DateOnly(2000, 1, 25), date.Last(DayOfWeek.Tuesday));
+        Assert.AreEqual(new DateOnly(2000, 1, 26), date.Last(DayOfWeek.Wednesday));
+        Assert.AreEqual(new DateOnly(2000, 1, 27), date.Last(DayOfWeek.Thursday));
+        Assert.AreEqual(new DateOnly(2000, 1, 28), date.Last(DayOfWeek.Friday));
+    }
+
+    [TestMethod]
+    public void LastDayOfMonth_ShouldBe28th_GivenFebruary1999()
+    {
+        var february = new DateOnly(1999, 2, 1);
+
+        Assert.AreEqual(new DateOnly(february.Year, february.Month, 28), february.LastDayOfMonth());
+    }
+
+    [TestMethod]
+    public void LastDayOfMonth_ShouldBe29th_GivenFebruary2000()
+    {
+        var february = new DateOnly(2000, 2, 1);
+
+        Assert.AreEqual(new DateOnly(february.Year, february.Month, 29), february.LastDayOfMonth());
+    }
+
+    [TestMethod]
+    public void LastDayOfMonth_ShouldBe28th_GivenFebruary2001()
+    {
+        var february = new DateOnly(2001, 2, 1);
+
+        Assert.AreEqual(new DateOnly(february.Year, february.Month, 28), february.LastDayOfMonth());
+    }
+
+    [TestMethod]
+    public void LastDayOfMonth_ShouldBe30th_GivenAprilJuneSeptemberNovember()
+    {
+        var april = new DateOnly(2000, 4, 1);
+        var june = new DateOnly(2000, 6, 1);
+        var september = new DateOnly(2000, 9, 1);
+        var november = new DateOnly(2000, 11, 1);
+
+        Assert.AreEqual(new DateOnly(april.Year, april.Month, 30), april.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(june.Year, june.Month, 30), june.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(september.Year, september.Month, 30), september.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(november.Year, november.Month, 30), november.LastDayOfMonth());
+    }
+
+    [TestMethod]
+    public void LastDayOfMonth_ShouldBe31st_GivenJanuaryMarchMayJulyAugustOctoberDecember()
+    {
+        var january = new DateOnly(2000, 1, 1);
+        var march = new DateOnly(2000, 3, 1);
+        var may = new DateOnly(2000, 5, 1);
+        var july = new DateOnly(2000, 7, 1);
+        var august = new DateOnly(2000, 8, 1);
+        var october = new DateOnly(2000, 10, 1);
+        var december = new DateOnly(2000, 12, 1);
+
+        Assert.AreEqual(new DateOnly(january.Year, january.Month, 31), january.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(march.Year, march.Month, 31), march.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(may.Year, may.Month, 31), may.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(july.Year, july.Month, 31), july.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(august.Year, august.Month, 31), august.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(october.Year, october.Month, 31), october.LastDayOfMonth());
+        Assert.AreEqual(new DateOnly(december.Year, december.Month, 31), december.LastDayOfMonth());
+    }
+
+    [TestMethod]
+    public void NextSaturday_ShouldBe8th_Given1Jan2000()
+    {
+        var date = new DateOnly(2000, 1, 1);
+
+        Assert.AreEqual(new DateOnly(2000, 1, 8), date.Next(DayOfWeek.Saturday));
+    }
+
+    [TestMethod]
+    public void ToUnixTimeMilliseconds_ShouldBe946684800000_Given1Jan2000()
+    {
+        var date = new DateOnly(2000, 1, 1);
+        var time = new TimeOnly(0, 0, 0);
+
+        Assert.AreEqual(946684800000, date.ToUnixTimeMilliseconds(time));
+    }
+
+    [TestMethod]
+    public void ToUnixTimeSeconds_ShouldBe946684800_Given1Jan2000()
+    {
+        var date = new DateOnly(2000, 1, 1);
+        var time = new TimeOnly(0, 0, 0);
+
+        Assert.AreEqual(946684800, date.ToUnixTimeSeconds(time));
+    }
+}
+#endif

X10D.Unity/X10D.Unity.csproj

@@ -16,7 +16,7 @@
         <PackageTags>dotnet extension-methods</PackageTags>
         <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/../CHANGELOG.md"))</PackageReleaseNotes>
         <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
-        <VersionPrefix>3.2.0</VersionPrefix>
+        <VersionPrefix>4.0.0</VersionPrefix>
         <Nullable>enable</Nullable>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>

X10D.Unity/src/Drawing/Color32Extensions.cs

@@ -27,11 +27,7 @@ public static class Color32Extensions
     ///     When this method returns, contains the <see cref="Color32.b" /> component of <paramref name="color" />.
     /// </param>
     [Pure]
-#if NETSTANDARD2_1
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
     public static void Deconstruct(this Color32 color, out byte a, out byte r, out byte g, out byte b)
     {
         a = color.a;
@@ -52,11 +48,7 @@ public static class Color32Extensions
     ///     When this method returns, contains the <see cref="Color32.b" /> component of <paramref name="color" />.
     /// </param>
     [Pure]
-#if NETSTANDARD2_1
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
     public static void Deconstruct(this Color32 color, out byte r, out byte g, out byte b)
     {
         r = color.r;

X10D.Unity/src/Drawing/ColorExtensions.cs

@@ -27,11 +27,7 @@ public static class ColorExtensions
     ///     When this method returns, contains the <see cref="Color.b" /> component of <paramref name="color" />.
     /// </param>
     [Pure]
-#if NETSTANDARD2_1
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
     public static void Deconstruct(this Color color, out float a, out float r, out float g, out float b)
     {
         a = color.a;
@@ -52,11 +48,7 @@ public static class ColorExtensions
     ///     When this method returns, contains the <see cref="Color.b" /> component of <paramref name="color" />.
     /// </param>
     [Pure]
-#if NETSTANDARD2_1
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
     public static void Deconstruct(this Color color, out float r, out float g, out float b)
     {
         r = color.r;

X10D/X10D.csproj

@@ -17,7 +17,7 @@
         <PackageReadmeFile>README.md</PackageReadmeFile>
         <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/../CHANGELOG.md"))</PackageReleaseNotes>
         <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
-        <VersionPrefix>3.2.0</VersionPrefix>
+        <VersionPrefix>4.0.0</VersionPrefix>
         <Nullable>enable</Nullable>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>

X10D/src/Collections/ByteExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 #if NETCOREAPP3_0_OR_GREATER
 using System.Runtime.Intrinsics;
@@ -22,11 +23,7 @@ public static class ByteExtensions
     /// <param name="value">The value to unpack.</param>
     /// <returns>An array of <see cref="bool" /> with length 8.</returns>
     [Pure]
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool[] Unpack(this byte value)
     {
         var buffer = new bool[Size];
@@ -41,11 +38,7 @@ public static class ByteExtensions
     /// <param name="destination">When this method returns, contains the unpacked booleans from <paramref name="value" />.</param>
     /// <exception cref="ArgumentException"><paramref name="destination" /> is not large enough to contain the result.</exception>
     [ExcludeFromCodeCoverage]
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static void Unpack(this byte value, Span<bool> destination)
     {
         if (destination.Length < Size)
@@ -64,11 +57,7 @@ public static class ByteExtensions
         UnpackInternal_Fallback(value, destination);
     }
 
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static void UnpackInternal_Fallback(this byte value, Span<bool> destination)
     {
         for (var index = 0; index < Size; index++)
@@ -78,11 +67,7 @@ public static class ByteExtensions
     }
 
 #if NETCOREAPP3_0_OR_GREATER
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal unsafe static void UnpackInternal_Ssse3(this byte value, Span<bool> destination)
     {
         fixed (bool* pDestination = destination)

X10D/src/Collections/Int16Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 #if NETCOREAPP3_0_OR_GREATER
 using System.Runtime.Intrinsics;
@@ -22,11 +23,7 @@ public static class Int16Extensions
     /// <param name="value">The value to unpack.</param>
     /// <returns>An array of <see cref="bool" /> with length 16.</returns>
     [Pure]
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool[] Unpack(this short value)
     {
         var ret = new bool[Size];
@@ -41,11 +38,7 @@ public static class Int16Extensions
     /// <param name="destination">When this method returns, contains the unpacked booleans from <paramref name="value" />.</param>
     /// <exception cref="ArgumentException"><paramref name="destination" /> is not large enough to contain the result.</exception>
     [ExcludeFromCodeCoverage]
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static void Unpack(this short value, Span<bool> destination)
     {
         if (destination.Length < Size)
@@ -64,11 +57,7 @@ public static class Int16Extensions
         UnpackInternal_Fallback(value, destination);
     }
 
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static void UnpackInternal_Fallback(this short value, Span<bool> destination)
     {
         for (var index = 0; index < Size; index++)
@@ -78,11 +67,7 @@ public static class Int16Extensions
     }
 
 #if NETCOREAPP3_0_OR_GREATER
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal unsafe static void UnpackInternal_Ssse3(this short value, Span<bool> destination)
     {
         fixed (bool* pDestination = destination)

X10D/src/Collections/Int32Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 #if NETCOREAPP3_0_OR_GREATER
 using System.Runtime.Intrinsics;
@@ -22,6 +23,7 @@ public static class Int32Extensions
     /// <param name="value">The value to unpack.</param>
     /// <returns>An array of <see cref="bool" /> with length 32.</returns>
     [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool[] Unpack(this int value)
     {
         var ret = new bool[Size];
@@ -36,6 +38,7 @@ public static class Int32Extensions
     /// <param name="destination">When this method returns, contains the unpacked booleans from <paramref name="value" />.</param>
     /// <exception cref="ArgumentException"><paramref name="destination" /> is not large enough to contain the result.</exception>
     [ExcludeFromCodeCoverage]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static void Unpack(this int value, Span<bool> destination)
     {
         if (destination.Length < Size)
@@ -60,11 +63,7 @@ public static class Int32Extensions
         UnpackInternal_Fallback(value, destination);
     }
 
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static void UnpackInternal_Fallback(this int value, Span<bool> destination)
     {
         for (var index = 0; index < Size; index++)
@@ -74,11 +73,7 @@ public static class Int32Extensions
     }
 
 #if NETCOREAPP3_0_OR_GREATER
-#if NETCOREAPP3_1_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static unsafe void UnpackInternal_Ssse3(this int value, Span<bool> destination)
     {
         fixed (bool* pDestination = destination)

X10D/src/CompilerServices/CompilerResources.cs

@@ -0,0 +1,13 @@
+using System.Runtime.CompilerServices;
+
+namespace X10D.CompilerServices;
+
+internal static class CompilerResources
+{
+#if NETCOREAPP3_0_OR_GREATER
+    public const MethodImplOptions MethodImplOptions = System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining |
+                                                       System.Runtime.CompilerServices.MethodImplOptions.AggressiveOptimization;
+#else
+    public const MethodImplOptions MethodImplOptions = System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining;
+#endif
+}

X10D/src/Core/IntrinsicExtensions.cs

@@ -4,6 +4,7 @@ using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using X10D.CompilerServices;
 
 namespace X10D.Core;
 
@@ -29,7 +30,7 @@ public static class IntrinsicExtensions
     /// A <see cref="Vector64{T}"/> of <see langword="byte"/> which remapped back to 0 and 1 based on boolean truthiness.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector64<byte> CorrectBoolean(this Vector64<byte> vector)
     {
         Vector64<byte> output = IntrinsicUtility.GetUninitializedVector64<byte>();
@@ -64,7 +65,7 @@ public static class IntrinsicExtensions
     /// A <see cref="Vector128{T}"/> of <see langword="byte"/> which remapped back to 0 and 1 based on boolean truthiness.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static Vector128<byte> CorrectBoolean(this Vector128<byte> vector)
     {
@@ -87,7 +88,7 @@ public static class IntrinsicExtensions
     /// A <see cref="Vector256{T}"/> of <see langword="byte"/> which remapped back to 0 and 1 based on boolean truthiness.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static Vector256<byte> CorrectBoolean(this Vector256<byte> vector)
     {
@@ -111,7 +112,7 @@ public static class IntrinsicExtensions
     /// </returns>
     [Pure]
     [CLSCompliant(false)]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static Vector128<ulong> ReverseElements(this Vector128<ulong> vector)
     {
@@ -119,7 +120,7 @@ public static class IntrinsicExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<byte> CorrectBooleanInternal_Fallback(this Vector128<byte> vector)
     {
         Vector128<byte> output = IntrinsicUtility.GetUninitializedVector128<byte>();
@@ -134,7 +135,7 @@ public static class IntrinsicExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<byte> CorrectBooleanInternal_Sse2(this Vector128<byte> vector)
     {
         Vector128<byte> cmp = Sse2.CompareEqual(vector, Vector128<byte>.Zero);
@@ -144,7 +145,7 @@ public static class IntrinsicExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector256<byte> CorrectBooleanInternal_Fallback(this Vector256<byte> vector)
     {
         Vector256<byte> output = IntrinsicUtility.GetUninitializedVector256<byte>();
@@ -159,7 +160,7 @@ public static class IntrinsicExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector256<byte> CorrectBooleanInternal_Avx2(this Vector256<byte> vector)
     {
         Vector256<byte> cmp = Avx2.CompareEqual(vector, Vector256<byte>.Zero);
@@ -169,7 +170,7 @@ public static class IntrinsicExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<ulong> ReverseElementsInternal_Fallback(this Vector128<ulong> vector)
     {
         Vector128<ulong> output = IntrinsicUtility.GetUninitializedVector128<ulong>();
@@ -181,7 +182,7 @@ public static class IntrinsicExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<ulong> ReverseElementsInternal_Sse2(this Vector128<ulong> vector)
     {
         return Sse2.Shuffle(vector.AsDouble(), vector.AsDouble(), 0b01).AsUInt64();

X10D/src/Core/IntrinsicUtility.cs

@@ -5,6 +5,7 @@ using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
+using X10D.CompilerServices;
 
 namespace X10D.Core;
 
@@ -32,7 +33,7 @@ public static class IntrinsicUtility
     /// <returns>The truncated product vector.</returns>
     [Pure]
     [CLSCompliant(false)]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static Vector128<ulong> Multiply(Vector128<ulong> left, Vector128<ulong> right)
     {
@@ -63,7 +64,7 @@ public static class IntrinsicUtility
     /// </returns>
     [Pure]
     [CLSCompliant(false)]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static Vector256<ulong> Multiply(Vector256<ulong> lhs, Vector256<ulong> rhs)
     {
@@ -91,7 +92,7 @@ public static class IntrinsicUtility
     /// A <see cref="Vector128{T}"/> of <see langword="long"/> whose elements is 64-bit truncated product of lhs and rhs.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector128<long> Multiply(Vector128<long> lhs, Vector128<long> rhs)
     {
         return Multiply(lhs.AsUInt64(), rhs.AsUInt64()).AsInt64();
@@ -115,7 +116,7 @@ public static class IntrinsicUtility
     /// A <see cref="Vector256{T}"/> of <see langword="ulong"/> whose elements is 64-bit truncated product of lhs and rhs.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector256<long> Multiply(Vector256<long> lhs, Vector256<long> rhs)
     {
         return Multiply(lhs.AsUInt64(), rhs.AsUInt64()).AsInt64();
@@ -141,7 +142,7 @@ public static class IntrinsicUtility
     /// elements in lhs and rhs.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static Vector128<int> HorizontalOr(Vector128<int> left, Vector128<int> right)
     {
@@ -172,7 +173,7 @@ public static class IntrinsicUtility
     /// elements in lhs and rhs.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [CLSCompliant(false)]
     public static Vector128<uint> HorizontalOr(Vector128<uint> left, Vector128<uint> right)
     {
@@ -180,7 +181,7 @@ public static class IntrinsicUtility
     }
 
     // Helper methods
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector64<T> GetUninitializedVector64<T>() where T : struct
     {
 #if NET6_0_OR_GREATER
@@ -191,7 +192,7 @@ public static class IntrinsicUtility
 #endif
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<T> GetUninitializedVector128<T>() where T : struct
     {
 #if NET6_0_OR_GREATER
@@ -202,7 +203,7 @@ public static class IntrinsicUtility
 #endif
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector256<T> GetUninitializedVector256<T>() where T : struct
     {
 #if NET6_0_OR_GREATER
@@ -214,7 +215,7 @@ public static class IntrinsicUtility
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<int> HorizontalOr_Sse(Vector128<int> left, Vector128<int> right)
     {
         Vector128<float> leftSingle = left.AsSingle();
@@ -229,7 +230,7 @@ public static class IntrinsicUtility
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<int> HorizontalOrInternal_Fallback(Vector128<int> left, Vector128<int> right)
     {
         Vector128<int> output = GetUninitializedVector128<int>();
@@ -249,7 +250,7 @@ public static class IntrinsicUtility
 
     [Pure]
     [CLSCompliant(false)]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<ulong> MultiplyInternal_Fallback(Vector128<ulong> left, Vector128<ulong> right)
     {
         ulong leftInteger1 = Unsafe.As<Vector128<ulong>, ulong>(ref left);
@@ -267,7 +268,7 @@ public static class IntrinsicUtility
 
     [Pure]
     [CLSCompliant(false)]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector128<ulong> MultiplyInternal_Sse2(Vector128<ulong> left, Vector128<ulong> right)
     {
         // https://stackoverflow.com/questions/17863411/sse-multiplication-of-2-64-bit-integers
@@ -284,7 +285,7 @@ public static class IntrinsicUtility
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector256<ulong> MultiplyInternal_Fallback(Vector256<ulong> left, Vector256<ulong> right)
     {
         Vector256<ulong> output = GetUninitializedVector256<ulong>();
@@ -300,7 +301,7 @@ public static class IntrinsicUtility
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static Vector256<ulong> MultiplyInternal_Avx2(Vector256<ulong> left, Vector256<ulong> right)
     {
         // https://stackoverflow.com/questions/17863411/sse-multiplication-of-2-64-bit-integers

X10D/src/Core/SpanExtensions.cs

@@ -2,6 +2,7 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using X10D.CompilerServices;
 
 #if NETCOREAPP3_0_OR_GREATER
 using System.Runtime.Intrinsics;
@@ -48,11 +49,7 @@ public static class SpanExtensions
     /// </returns>
     /// <exception cref="ArgumentException">The size of <typeparamref name="T" /> is unsupported.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Contains<T>(this Span<T> span, T value) where T : struct, Enum
     {
         return Contains((ReadOnlySpan<T>)span, value);
@@ -71,11 +68,7 @@ public static class SpanExtensions
     /// </returns>
     /// <exception cref="ArgumentException">The size of <typeparamref name="T" /> is unsupported.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Contains<T>(this ReadOnlySpan<T> span, T value) where T : struct, Enum
     {
 #if NET6_0_OR_GREATER
@@ -141,11 +134,7 @@ public static class SpanExtensions
     /// <returns>An 8-bit unsigned integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 8 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte PackByte(this Span<bool> source)
     {
         return PackByte((ReadOnlySpan<bool>)source);
@@ -158,11 +147,7 @@ public static class SpanExtensions
     /// <returns>An 8-bit unsigned integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 8 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static byte PackByte(this ReadOnlySpan<bool> source)
     {
@@ -216,11 +201,7 @@ public static class SpanExtensions
     /// <returns>A 16-bit signed integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 16 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static short PackInt16(this ReadOnlySpan<bool> source)
     {
@@ -259,11 +240,7 @@ public static class SpanExtensions
     /// <returns>A 32-bit signed integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 32 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PackInt32(this Span<bool> source)
     {
         return PackInt32((ReadOnlySpan<bool>)source);
@@ -276,11 +253,7 @@ public static class SpanExtensions
     /// <returns>A 32-bit signed integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 32 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static int PackInt32(this ReadOnlySpan<bool> source)
     {
@@ -331,11 +304,7 @@ public static class SpanExtensions
     /// <returns>A 64-bit signed integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 64 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long PackInt64(this Span<bool> source)
     {
         return PackInt64((ReadOnlySpan<bool>)source);
@@ -348,11 +317,7 @@ public static class SpanExtensions
     /// <returns>A 64-bit signed integer containing the packed booleans.</returns>
     /// <exception cref="ArgumentException"><paramref name="source" /> contains more than 64 elements.</exception>
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long PackInt64(this ReadOnlySpan<bool> source)
     {
         switch (source.Length)
@@ -377,11 +342,7 @@ public static class SpanExtensions
     }
 
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static byte PackByteInternal_Fallback(this ReadOnlySpan<bool> source)
     {
         byte result = 0;
@@ -395,11 +356,7 @@ public static class SpanExtensions
     }
 
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static short PackInt16Internal_Fallback(this ReadOnlySpan<bool> source)
     {
         short result = 0;
@@ -413,11 +370,7 @@ public static class SpanExtensions
     }
 
     [Pure]
-#if NETCOREAPP3_0_OR_GREATER
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static int PackInt32Internal_Fallback(this ReadOnlySpan<bool> source)
     {
         var result = 0;
@@ -432,7 +385,7 @@ public static class SpanExtensions
 
 #if NETCOREAPP3_0_OR_GREATER
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static byte PackByteInternal_Sse2(this ReadOnlySpan<bool> source)
     {
         unsafe
@@ -446,7 +399,7 @@ public static class SpanExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static short PackInt16Internal_Sse2(this ReadOnlySpan<bool> source)
     {
         unsafe
@@ -466,7 +419,7 @@ public static class SpanExtensions
     // dotcover disable
     //NOSONAR
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static int PackInt32Internal_AdvSimd(this ReadOnlySpan<bool> source)
     {
         unsafe
@@ -493,7 +446,7 @@ public static class SpanExtensions
     // dotcover enable
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static int PackInt32Internal_Avx2(this ReadOnlySpan<bool> source)
     {
         unsafe
@@ -518,7 +471,7 @@ public static class SpanExtensions
     }
 
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static int PackInt32Internal_Sse2(this ReadOnlySpan<bool> source)
     {
         unsafe
@@ -550,7 +503,7 @@ public static class SpanExtensions
     // dotcover disable
     //NOSONAR
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     internal static byte PackByteInternal_AdvSimd(this ReadOnlySpan<bool> source)
     {
         unsafe

X10D/src/Drawing/ColorExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Drawing;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Drawing;
 
@@ -26,11 +27,7 @@ public static class ColorExtensions
     ///     When this method returns, contains the <see cref="Color.B" /> component of <paramref name="color" />.
     /// </param>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static void Deconstruct(this Color color, out byte a, out byte r, out byte g, out byte b)
     {
         a = color.A;
@@ -51,11 +48,7 @@ public static class ColorExtensions
     ///     When this method returns, contains the <see cref="Color.B" /> component of <paramref name="color" />.
     /// </param>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static void Deconstruct(this Color color, out byte r, out byte g, out byte b)
     {
         r = color.R;
@@ -70,11 +63,7 @@ public static class ColorExtensions
     /// <returns>The closest <see cref="ConsoleColor" />.</returns>
     /// <author>Glenn Slayden, https://stackoverflow.com/a/12340136/1467293</author>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ConsoleColor GetClosestConsoleColor(this Color color)
     {
         ConsoleColor result = 0;
@@ -121,11 +110,7 @@ public static class ColorExtensions
     /// <param name="color">The color to invert.</param>
     /// <returns>The inverted color.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Color Inverted(this Color color)
     {
         return Color.FromArgb(color.A, 255 - color.R, 255 - color.G, 255 - color.B);
@@ -143,11 +128,7 @@ public static class ColorExtensions
     ///     <see cref="Color.A" /> component is <paramref name="a" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Color WithA(this Color color, int a)
     {
         return Color.FromArgb(a, color.R, color.G, color.B);
@@ -165,11 +146,7 @@ public static class ColorExtensions
     ///     <see cref="Color.B" /> component is <paramref name="b" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Color WithB(this Color color, int b)
     {
         return Color.FromArgb(color.A, color.R, color.G, b);
@@ -187,11 +164,7 @@ public static class ColorExtensions
     ///     <see cref="Color.G" /> component is <paramref name="g" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Color WithG(this Color color, int g)
     {
         return Color.FromArgb(color.A, color.R, g, color.B);
@@ -209,11 +182,7 @@ public static class ColorExtensions
     ///     <see cref="Color.R" /> component is <paramref name="r" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Color WithR(this Color color, int r)
     {
         return Color.FromArgb(color.A, r, color.G, color.B);

X10D/src/Drawing/PointExtensions.cs

@@ -2,6 +2,7 @@
 using System.Drawing;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Drawing;
 
@@ -20,11 +21,7 @@ public static class PointExtensions
     ///     <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this Point point, LineF line)
     {
         return ((PointF)point).IsOnLine(line);
@@ -41,11 +38,7 @@ public static class PointExtensions
     ///     <paramref name="end" />; otherwise <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this Point point, PointF start, PointF end)
     {
         return point.IsOnLine(new LineF(start, end));
@@ -62,11 +55,7 @@ public static class PointExtensions
     ///     <paramref name="end" />; otherwise <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this Point point, Vector2 start, Vector2 end)
     {
         return point.IsOnLine(new LineF(start, end));
@@ -78,11 +67,7 @@ public static class PointExtensions
     /// <param name="point">The point to convert.</param>
     /// <returns>The resulting <see cref="Size" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Size ToSize(this Point point)
     {
         return new Size(point.X, point.Y);

X10D/src/Drawing/PointFExtensions.cs

@@ -2,6 +2,7 @@
 using System.Drawing;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Drawing;
@@ -21,11 +22,7 @@ public static class PointFExtensions
     ///     <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this PointF point, LineF line)
     {
         (float x1, float x2) = (line.Start.X, line.End.X);
@@ -45,11 +42,7 @@ public static class PointFExtensions
     ///     <paramref name="end" />; otherwise <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this PointF point, PointF start, PointF end)
     {
         return point.IsOnLine(new LineF(start, end));
@@ -66,11 +59,7 @@ public static class PointFExtensions
     ///     <paramref name="end" />; otherwise <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this PointF point, Vector2 start, Vector2 end)
     {
         return point.IsOnLine(new LineF(start, end));
@@ -82,11 +71,7 @@ public static class PointFExtensions
     /// <param name="point">The point whose components to round.</param>
     /// <returns>The rounded point.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static PointF Round(this PointF point)
     {
         return point.Round(1.0f);
@@ -99,11 +84,7 @@ public static class PointFExtensions
     /// <param name="nearest">The nearest multiple to which the components should be rounded.</param>
     /// <returns>The rounded point.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static PointF Round(this PointF point, float nearest)
     {
         float x = point.X.Round(nearest);
@@ -117,11 +98,7 @@ public static class PointFExtensions
     /// <param name="point">The point to convert.</param>
     /// <returns>The resulting <see cref="SizeF" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static SizeF ToSizeF(this PointF point)
     {
         return new SizeF(point.X, point.Y);

X10D/src/Drawing/SizeExtensions.cs

@@ -2,6 +2,7 @@
 using System.Drawing;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Drawing;
 
@@ -16,11 +17,7 @@ public static class SizeExtensions
     /// <param name="size">The size to convert.</param>
     /// <returns>The resulting <see cref="Point" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Point ToPoint(this Size size)
     {
         return new Point(size.Width, size.Height);
@@ -32,11 +29,7 @@ public static class SizeExtensions
     /// <param name="size">The size to convert.</param>
     /// <returns>The resulting <see cref="PointF" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static PointF ToPointF(this Size size)
     {
         return new PointF(size.Width, size.Height);
@@ -48,11 +41,7 @@ public static class SizeExtensions
     /// <param name="size">The size to convert.</param>
     /// <returns>The resulting <see cref="Vector2" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector2 ToVector2(this Size size)
     {
         return new Vector2(size.Width, size.Height);

X10D/src/Math/BigIntegerExtensions.cs

@@ -0,0 +1,253 @@
+using System.Diagnostics.Contracts;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
+
+namespace X10D.Math;
+
+/// <summary>
+///     Math-related extension methods for <see cref="BigInteger" />.
+/// </summary>
+public static class BigIntegerExtensions
+{
+    /// <summary>
+    ///     Computes the digital root of this 8-bit integer.
+    /// </summary>
+    /// <param name="value">The value whose digital root to compute.</param>
+    /// <returns>The digital root of <paramref name="value" />.</returns>
+    /// <remarks>The digital root is defined as the recursive sum of digits until that result is a single digit.</remarks>
+    /// <remarks>
+    ///     <para>The digital root is defined as the recursive sum of digits until that result is a single digit.</para>
+    ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
+    /// </remarks>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static int DigitalRoot(this BigInteger value)
+    {
+        BigInteger root = BigInteger.Abs(value).Mod(9);
+        return (int)(root == 0 ? 9 : root);
+    }
+
+    /// <summary>
+    ///     Returns the factorial of the current 64-bit signed integer.
+    /// </summary>
+    /// <param name="value">The value whose factorial to compute.</param>
+    /// <returns>The factorial of <paramref name="value" />.</returns>
+    /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static BigInteger Factorial(this BigInteger value)
+    {
+        if (value < 0)
+        {
+            throw new ArithmeticException(nameof(value));
+        }
+
+        if (value == 0)
+        {
+            return 1;
+        }
+
+        BigInteger result = 1;
+        for (var i = 1L; i <= value; i++)
+        {
+            result *= i;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    ///     Calculates the greatest common factor between this, and another, <see cref="BigInteger" />.
+    /// </summary>
+    /// <param name="value">The first value.</param>
+    /// <param name="other">The second value.</param>
+    /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static BigInteger GreatestCommonFactor(this BigInteger value, BigInteger other)
+    {
+        while (other != 0)
+        {
+            (value, other) = (other, value % other);
+        }
+
+        return value;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is not evenly divisible by 2.
+    /// </summary>
+    /// <param name="value">The value whose parity to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is not evenly divisible by 2, or <see langword="false" />
+    ///     otherwise.
+    /// </returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static bool IsOdd(this BigInteger value)
+    {
+        return !value.IsEven;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the current value is a prime number.
+    /// </summary>
+    /// <param name="value">The value whose primality to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
+    /// </returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static bool IsPrime(this BigInteger value)
+    {
+        if (value <= 1)
+        {
+            return false;
+        }
+
+        if (value <= 3)
+        {
+            return true;
+        }
+
+        if (value.IsEven || value % 3 == 0)
+        {
+            return false;
+        }
+
+        for (var iterator = 5L; iterator * iterator <= value; iterator += 6)
+        {
+            if (value % iterator == 0 || value % (iterator + 2) == 0)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Calculates the lowest common multiple between the current 64-bit signed integer, and another 64-bit signed integer.
+    /// </summary>
+    /// <param name="value">The first value.</param>
+    /// <param name="other">The second value.</param>
+    /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static BigInteger LowestCommonMultiple(this BigInteger value, BigInteger other)
+    {
+        if (value == 0 || other == 0)
+        {
+            return 0;
+        }
+
+        if (value == 1)
+        {
+            return other;
+        }
+
+        if (other == 1)
+        {
+            return value;
+        }
+
+        return value * other / value.GreatestCommonFactor(other);
+    }
+
+    /// <summary>
+    ///     Performs a modulo operation which supports a negative dividend.
+    /// </summary>
+    /// <param name="dividend">The dividend.</param>
+    /// <param name="divisor">The divisor.</param>
+    /// <returns>The result of <c>dividend mod divisor</c>.</returns>
+    /// <remarks>
+    ///     The <c>%</c> operator (commonly called the modulo operator) in C# is not defined to be modulo, but is instead
+    ///     remainder. This quirk inherently makes it difficult to use modulo in a negative context, as <c>x % y</c> where x is
+    ///     negative will return a negative value, akin to <c>-(x % y)</c>, even if precedence is forced. This method provides a
+    ///     modulo operation which supports negative dividends.
+    /// </remarks>
+    /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
+    /// <license>CC-BY-SA 2.5</license>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static BigInteger Mod(this BigInteger dividend, BigInteger divisor)
+    {
+        BigInteger r = dividend % divisor;
+        return r < 0 ? r + divisor : r;
+    }
+
+    /// <summary>
+    ///     Returns the multiplicative persistence of a specified value.
+    /// </summary>
+    /// <param name="value">The value whose multiplicative persistence to calculate.</param>
+    /// <returns>The multiplicative persistence.</returns>
+    /// <remarks>
+    ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
+    /// </remarks>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static int MultiplicativePersistence(this BigInteger value)
+    {
+        var persistence = 0;
+        BigInteger product = BigInteger.Abs(value);
+
+        while (product > 9)
+        {
+            if (value % 10 == 0)
+            {
+                return persistence + 1;
+            }
+
+            while (value > 9)
+            {
+                value /= 10;
+                if (value % 10 == 0)
+                {
+                    return persistence + 1;
+                }
+            }
+
+            BigInteger newProduct = 1;
+            BigInteger currentProduct = product;
+            while (currentProduct > 0)
+            {
+                newProduct *= currentProduct % 10;
+                currentProduct /= 10;
+            }
+
+            product = newProduct;
+            persistence++;
+        }
+
+        return persistence;
+    }
+
+    /// <summary>
+    ///     Wraps the current integer between a low and a high value.
+    /// </summary>
+    /// <param name="value">The value to wrap.</param>
+    /// <param name="low">The inclusive lower bound.</param>
+    /// <param name="high">The exclusive upper bound.</param>
+    /// <returns>The wrapped value.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static BigInteger Wrap(this BigInteger value, BigInteger low, BigInteger high)
+    {
+        BigInteger difference = high - low;
+        return low + (((value - low) % difference) + difference) % difference;
+    }
+
+    /// <summary>
+    ///     Wraps the current integer between 0 and a high value.
+    /// </summary>
+    /// <param name="value">The value to wrap.</param>
+    /// <param name="length">The exclusive upper bound.</param>
+    /// <returns>The wrapped value.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static BigInteger Wrap(this BigInteger value, BigInteger length)
+    {
+        return ((value % length) + length) % length;
+    }
+}

X10D/src/Math/ByteExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -19,11 +20,7 @@ public static class ByteExtensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte DigitalRoot(this byte value)
     {
         int root = value % 9;
@@ -36,11 +33,7 @@ public static class ByteExtensions
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Factorial(this byte value)
     {
         if (value == 0)
@@ -64,11 +57,7 @@ public static class ByteExtensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte GreatestCommonFactor(this byte value, byte other)
     {
         return (byte)((long)value).GreatestCommonFactor(other);
@@ -83,11 +72,7 @@ public static class ByteExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this byte value)
     {
         return (value & 1) == 0;
@@ -102,11 +87,7 @@ public static class ByteExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this byte value)
     {
         return !value.IsEven();
@@ -132,11 +113,7 @@ public static class ByteExtensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte LowestCommonMultiple(this byte value, byte other)
     {
         return (byte)((long)value).LowestCommonMultiple(other);
@@ -151,11 +128,7 @@ public static class ByteExtensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this byte value)
     {
         return ((long)value).MultiplicativePersistence();
@@ -169,11 +142,7 @@ public static class ByteExtensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte Wrap(this byte value, byte low, byte high)
     {
         return (byte)((ulong)value).Wrap(low, high);
@@ -186,11 +155,7 @@ public static class ByteExtensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte Wrap(this byte value, byte length)
     {
         return (byte)((ulong)value).Wrap(length);

X10D/src/Math/ComparableExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -48,11 +49,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Between<T1, T2, T3>(this T1 value, T2 lower, T3 upper,
         InclusiveOptions inclusiveOptions = InclusiveOptions.None)
         where T1 : IComparable<T2>, IComparable<T3>
@@ -113,11 +110,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static T Clamp<T>(this T value, T lower, T upper)
         where T : IComparable<T>
     {
@@ -163,11 +156,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool GreaterThan<T1, T2>(this T1 value, T2 other)
         where T1 : IComparable<T2>
     {
@@ -206,11 +195,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool GreaterThanOrEqualTo<T1, T2>(this T1 value, T2 other)
         where T1 : IComparable<T2>
     {
@@ -249,11 +234,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool LessThan<T1, T2>(this T1 value, T2 other)
         where T1 : IComparable<T2>
     {
@@ -292,11 +273,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool LessThanOrEqualTo<T1, T2>(this T1 value, T2 other)
         where T1 : IComparable<T2>
     {
@@ -334,11 +311,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static T Max<T>(this T value, T other)
         where T : IComparable<T>
     {
@@ -376,11 +349,7 @@ public static class ComparableExtensions
     /// </example>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static T Min<T>(this T value, T other)
         where T : IComparable<T>
     {

X10D/src/Math/DecimalExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -15,11 +16,7 @@ public static class DecimalExtensions
     /// <param name="value">The number whose square root is to be found.</param>
     /// <returns>The square root of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Complex ComplexSqrt(this decimal value)
     {
         return Complex.Sqrt((double)value);
@@ -34,11 +31,7 @@ public static class DecimalExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this decimal value)
     {
         return value % 2.0m == 0.0m;
@@ -53,11 +46,7 @@ public static class DecimalExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this decimal value)
     {
         return !value.IsEven();
@@ -69,11 +58,7 @@ public static class DecimalExtensions
     /// <param name="value">The value to round.</param>
     /// <returns><paramref name="value" /> rounded to the nearest whole number.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static decimal Round(this decimal value)
     {
         return value.Round(1.0m);
@@ -86,11 +71,7 @@ public static class DecimalExtensions
     /// <param name="nearest">The nearest multiple to which <paramref name="value" /> should be rounded.</param>
     /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static decimal Round(this decimal value, decimal nearest)
     {
         return System.Math.Round(value / nearest) * nearest;
@@ -103,11 +84,7 @@ public static class DecimalExtensions
     /// <returns>The saturated value.</returns>
     /// <remarks>This method clamps <paramref name="value" /> between 0 and 1.</remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static decimal Saturate(this decimal value)
     {
         return System.Math.Clamp(value, 0.0m, 1.0m);
@@ -141,11 +118,7 @@ public static class DecimalExtensions
     ///     </list>
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this decimal value)
     {
         return System.Math.Sign(value);
@@ -180,11 +153,7 @@ public static class DecimalExtensions
     /// </returns>
     /// <exception cref="ArgumentException"><paramref name="value" /> is negative.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static decimal Sqrt(this decimal value)
     {
         switch (value)
@@ -214,11 +183,7 @@ public static class DecimalExtensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static decimal Wrap(this decimal value, decimal low, decimal high)
     {
         decimal difference = high - low;
@@ -232,11 +197,7 @@ public static class DecimalExtensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static decimal Wrap(this decimal value, decimal length)
     {
         return ((value % length) + length) % length;

X10D/src/Math/DoubleExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -20,11 +21,7 @@ public static class DoubleExtensions
     ///     is equal to <see cref="double.NaN" />, less than -1, or greater than 1, <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Acos(this double value)
     {
         return System.Math.Acos(value);
@@ -42,11 +39,7 @@ public static class DoubleExtensions
     ///     <paramref name="value" /> is less than 1 or equal to <see cref="double.NaN" />, <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Acosh(this double value)
     {
         return System.Math.Acosh(value);
@@ -64,11 +57,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Asin(this double value)
     {
         return System.Math.Asin(value);
@@ -86,11 +75,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />, <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Asinh(this double value)
     {
         return System.Math.Asinh(value);
@@ -107,11 +92,7 @@ public static class DoubleExtensions
     ///     <paramref name="value" /> is equal to <see cref="double.NaN" />, <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Atan(this double value)
     {
         return System.Math.Atan(value);
@@ -130,11 +111,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Atanh(this double value)
     {
         return System.Math.Atanh(value);
@@ -146,11 +123,7 @@ public static class DoubleExtensions
     /// <param name="value">The number whose square root is to be found.</param>
     /// <returns>The square root of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Complex ComplexSqrt(this double value)
     {
         switch (value)
@@ -180,11 +153,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Cos(this double value)
     {
         return System.Math.Cos(value);
@@ -201,11 +170,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />, <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Cosh(this double value)
     {
         return System.Math.Cosh(value);
@@ -217,11 +182,7 @@ public static class DoubleExtensions
     /// <param name="value">The angle in degrees to convert.</param>
     /// <returns>The result of π * <paramref name="value" /> / 180.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double DegreesToRadians(this double value)
     {
         return value * (System.Math.PI / 180.0);
@@ -236,11 +197,7 @@ public static class DoubleExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this double value)
     {
         return System.Math.Abs(value % 2.0) < double.Epsilon;
@@ -255,11 +212,7 @@ public static class DoubleExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this double value)
     {
         return !value.IsEven();
@@ -271,11 +224,7 @@ public static class DoubleExtensions
     /// <param name="value">The angle in radians to convert.</param>
     /// <returns>The result of π * <paramref name="value" /> / 180.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double RadiansToDegrees(this double value)
     {
         return value * (180.0 / System.Math.PI);
@@ -287,11 +236,7 @@ public static class DoubleExtensions
     /// <param name="value">The value to round.</param>
     /// <returns><paramref name="value" /> rounded to the nearest whole number.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Round(this double value)
     {
         return value.Round(1.0);
@@ -304,11 +249,7 @@ public static class DoubleExtensions
     /// <param name="nearest">The nearest multiple to which <paramref name="value" /> should be rounded.</param>
     /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Round(this double value, double nearest)
     {
         return System.Math.Round(value / nearest) * nearest;
@@ -321,11 +262,7 @@ public static class DoubleExtensions
     /// <returns>The saturated value.</returns>
     /// <remarks>This method clamps <paramref name="value" /> between 0 and 1.</remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Saturate(this double value)
     {
         return System.Math.Clamp(value, 0.0, 1.0);
@@ -341,11 +278,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Sin(this double value)
     {
         return System.Math.Sin(value);
@@ -361,11 +294,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Sinh(this double value)
     {
         return System.Math.Sinh(value);
@@ -400,11 +329,7 @@ public static class DoubleExtensions
     /// </returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is equal to <see cref="double.NaN" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this double value)
     {
         return System.Math.Sign(value);
@@ -440,11 +365,7 @@ public static class DoubleExtensions
     /// <author>SLenik https://stackoverflow.com/a/6755197/1467293</author>
     /// <license>CC BY-SA 3.0</license>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Sqrt(this double value)
     {
         switch (value)
@@ -478,11 +399,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Tan(this double value)
     {
         return System.Math.Tan(value);
@@ -499,11 +416,7 @@ public static class DoubleExtensions
     ///     <see cref="double.NaN" />, this method returns <see cref="double.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Tanh(this double value)
     {
         return System.Math.Tanh(value);
@@ -517,11 +430,7 @@ public static class DoubleExtensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Wrap(this double value, double low, double high)
     {
         double difference = high - low;
@@ -535,11 +444,7 @@ public static class DoubleExtensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Wrap(this double value, double length)
     {
         return ((value % length) + length) % length;

X10D/src/Math/Int16Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -18,11 +19,7 @@ public static class Int16Extensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short DigitalRoot(this short value)
     {
         short root = System.Math.Abs(value).Mod(9);
@@ -36,11 +33,7 @@ public static class Int16Extensions
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Factorial(this short value)
     {
         if (value < 0)
@@ -69,11 +62,7 @@ public static class Int16Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short GreatestCommonFactor(this short value, short other)
     {
         return (short)((long)value).GreatestCommonFactor(other);
@@ -88,11 +77,7 @@ public static class Int16Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this short value)
     {
         return (value & 1) == 0;
@@ -107,11 +92,7 @@ public static class Int16Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this short value)
     {
         return !value.IsEven();
@@ -125,11 +106,7 @@ public static class Int16Extensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this short value)
     {
         return ((long)value).IsPrime();
@@ -142,11 +119,7 @@ public static class Int16Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short LowestCommonMultiple(this short value, short other)
     {
         return (short)((long)value).LowestCommonMultiple(other);
@@ -167,11 +140,7 @@ public static class Int16Extensions
     /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
     /// <license>CC-BY-SA 2.5</license>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short Mod(this short dividend, short divisor)
     {
         int r = dividend % divisor;
@@ -187,11 +156,7 @@ public static class Int16Extensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this short value)
     {
         return ((long)value).MultiplicativePersistence();
@@ -225,11 +190,7 @@ public static class Int16Extensions
     ///     </list>
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this short value)
     {
         return System.Math.Sign(value);
@@ -243,11 +204,7 @@ public static class Int16Extensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short Wrap(this short value, short low, short high)
     {
         return (short)((long)value).Wrap(low, high);
@@ -260,11 +217,7 @@ public static class Int16Extensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short Wrap(this short value, short length)
     {
         return (short)((long)value).Wrap(length);

X10D/src/Math/Int32Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -18,11 +19,7 @@ public static class Int32Extensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int DigitalRoot(this int value)
     {
         int root = System.Math.Abs(value).Mod(9);
@@ -36,11 +33,7 @@ public static class Int32Extensions
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Factorial(this int value)
     {
         if (value < 0)
@@ -69,11 +62,7 @@ public static class Int32Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int GreatestCommonFactor(this int value, int other)
     {
         return (int)((long)value).GreatestCommonFactor(other);
@@ -88,11 +77,7 @@ public static class Int32Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this int value)
     {
         return (value & 1) == 0;
@@ -107,11 +92,7 @@ public static class Int32Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this int value)
     {
         return !value.IsEven();
@@ -125,11 +106,7 @@ public static class Int32Extensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this int value)
     {
         return ((long)value).IsPrime();
@@ -142,11 +119,7 @@ public static class Int32Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int LowestCommonMultiple(this int value, int other)
     {
         return (int)((long)value).LowestCommonMultiple(other);
@@ -167,11 +140,7 @@ public static class Int32Extensions
     /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
     /// <license>CC-BY-SA 2.5</license>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Mod(this int dividend, int divisor)
     {
         int r = dividend % divisor;
@@ -187,11 +156,7 @@ public static class Int32Extensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this int value)
     {
         return ((long)value).MultiplicativePersistence();
@@ -225,11 +190,7 @@ public static class Int32Extensions
     ///     </list>
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this int value)
     {
         return System.Math.Sign(value);
@@ -243,11 +204,7 @@ public static class Int32Extensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Wrap(this int value, int low, int high)
     {
         return (int)((long)value).Wrap(low, high);
@@ -260,11 +217,7 @@ public static class Int32Extensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Wrap(this int value, int length)
     {
         return (int)((long)value).Wrap(length);

X10D/src/Math/Int64Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -18,11 +19,7 @@ public static class Int64Extensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long DigitalRoot(this long value)
     {
         long root = System.Math.Abs(value).Mod(9L);
@@ -36,11 +33,7 @@ public static class Int64Extensions
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Factorial(this long value)
     {
         if (value < 0)
@@ -69,11 +62,7 @@ public static class Int64Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long GreatestCommonFactor(this long value, long other)
     {
         while (other != 0)
@@ -93,11 +82,7 @@ public static class Int64Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this long value)
     {
         return (value & 1) == 0;
@@ -112,11 +97,7 @@ public static class Int64Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this long value)
     {
         return !value.IsEven();
@@ -130,11 +111,7 @@ public static class Int64Extensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this long value)
     {
         switch (value)
@@ -166,11 +143,7 @@ public static class Int64Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long LowestCommonMultiple(this long value, long other)
     {
         if (value == 0 || other == 0)
@@ -206,11 +179,7 @@ public static class Int64Extensions
     /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
     /// <license>CC-BY-SA 2.5</license>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Mod(this long dividend, long divisor)
     {
         long r = dividend % divisor;
@@ -226,11 +195,7 @@ public static class Int64Extensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this long value)
     {
         var persistence = 0;
@@ -295,11 +260,7 @@ public static class Int64Extensions
     ///     </list>
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this long value)
     {
         return System.Math.Sign(value);
@@ -313,11 +274,7 @@ public static class Int64Extensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Wrap(this long value, long low, long high)
     {
         long difference = high - low;
@@ -331,11 +288,7 @@ public static class Int64Extensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Wrap(this long value, long length)
     {
         return ((value % length) + length) % length;

X10D/src/Math/MathUtility.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -69,11 +70,7 @@ public static class MathUtility
     /// <param name="value">The gamma-encoded value to convert. Expected range is [0, 1].</param>
     /// <returns>The linear value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float GammaToLinear(float value)
     {
         return GammaToLinear(value, DefaultGammaF);
@@ -86,11 +83,7 @@ public static class MathUtility
     /// <param name="gamma">The gamma value to use for decoding.</param>
     /// <returns>The linear value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float GammaToLinear(float value, float gamma)
     {
         return MathF.Pow(value, 1.0f / gamma);
@@ -102,11 +95,7 @@ public static class MathUtility
     /// <param name="value">The gamma-encoded value to convert. Expected range is [0, 1].</param>
     /// <returns>The linear value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double GammaToLinear(double value)
     {
         return GammaToLinear(value, DefaultGamma);
@@ -119,11 +108,7 @@ public static class MathUtility
     /// <param name="gamma">The gamma value to use for decoding.</param>
     /// <returns>The linear value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double GammaToLinear(double value, double gamma)
     {
         return System.Math.Pow(value, 1.0 / gamma);
@@ -138,11 +123,7 @@ public static class MathUtility
     /// <param name="end">The end of the range.</param>
     /// <returns>A value determined by <c>(alpha - start) / (end - start)</c>.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float InverseLerp(float alpha, float start, float end)
     {
         if (MathF.Abs(start - end) < float.Epsilon)
@@ -162,11 +143,7 @@ public static class MathUtility
     /// <param name="end">The end of the range.</param>
     /// <returns>A value determined by <c>(alpha - start) / (end - start)</c>.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double InverseLerp(double alpha, double start, double end)
     {
         if (System.Math.Abs(start - end) < double.Epsilon)
@@ -187,11 +164,7 @@ public static class MathUtility
     ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Lerp(float value, float target, float alpha)
     {
         // rookie mistake: a + t * (b - a)
@@ -209,11 +182,7 @@ public static class MathUtility
     ///     The interpolation result as determined by <c>(1 - alpha) * value + alpha * target</c>.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double Lerp(double value, double target, double alpha)
     {
         // rookie mistake: a + t * (b - a)
@@ -227,11 +196,7 @@ public static class MathUtility
     /// <param name="value">The linear value to convert. Expected range is [0, 1].</param>
     /// <returns>The gamma-encoded value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float LinearToGamma(float value)
     {
         return LinearToGamma(value, DefaultGammaF);
@@ -244,11 +209,7 @@ public static class MathUtility
     /// <param name="gamma">The gamma value to use for encoding.</param>
     /// <returns>The gamma-encoded value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float LinearToGamma(float value, float gamma)
     {
         return MathF.Pow(value, 1.0f / gamma);
@@ -260,11 +221,7 @@ public static class MathUtility
     /// <param name="value">The linear value to convert. Expected range is [0, 1].</param>
     /// <returns>The gamma-encoded value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double LinearToGamma(double value)
     {
         return LinearToGamma(value, DefaultGamma);
@@ -277,11 +234,7 @@ public static class MathUtility
     /// <param name="gamma">The gamma value to use for encoding.</param>
     /// <returns>The gamma-encoded value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double LinearToGamma(double value, double gamma)
     {
         return System.Math.Pow(value, 1.0 / gamma);
@@ -365,11 +318,7 @@ public static class MathUtility
     /// <param name="newMax">The new maximum value.</param>
     /// <returns>The scaled value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float ScaleRange(float value, float oldMin, float oldMax, float newMin, float newMax)
     {
         float oldRange = oldMax - oldMin;
@@ -388,11 +337,7 @@ public static class MathUtility
     /// <param name="newMax">The new maximum value.</param>
     /// <returns>The scaled value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static double ScaleRange(double value, double oldMin, double oldMax, double newMin, double newMax)
     {
         double oldRange = oldMax - oldMin;

X10D/src/Math/SByteExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -19,11 +20,7 @@ public static class SByteExtensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte DigitalRoot(this sbyte value)
     {
         int root = System.Math.Abs(value).Mod(9);
@@ -37,11 +34,7 @@ public static class SByteExtensions
     /// <returns>The factorial of <paramref name="value" />.</returns>
     /// <exception cref="ArithmeticException"><paramref name="value" /> is less than 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long Factorial(this sbyte value)
     {
         if (value < 0)
@@ -70,11 +63,7 @@ public static class SByteExtensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte GreatestCommonFactor(this sbyte value, sbyte other)
     {
         return (sbyte)((long)value).GreatestCommonFactor(other);
@@ -89,11 +78,7 @@ public static class SByteExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this sbyte value)
     {
         return (value & 1) == 0;
@@ -108,11 +93,7 @@ public static class SByteExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this sbyte value)
     {
         return !value.IsEven();
@@ -126,11 +107,7 @@ public static class SByteExtensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this sbyte value)
     {
         return ((long)value).IsPrime();
@@ -143,11 +120,7 @@ public static class SByteExtensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte LowestCommonMultiple(this sbyte value, sbyte other)
     {
         return (sbyte)((long)value).LowestCommonMultiple(other);
@@ -168,11 +141,7 @@ public static class SByteExtensions
     /// <author>ShreevatsaR, https://stackoverflow.com/a/1082938/1467293</author>
     /// <license>CC-BY-SA 2.5</license>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte Mod(this sbyte dividend, sbyte divisor)
     {
         int r = dividend % divisor;
@@ -188,11 +157,7 @@ public static class SByteExtensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this sbyte value)
     {
         return ((long)value).MultiplicativePersistence();
@@ -226,11 +191,7 @@ public static class SByteExtensions
     ///     </list>
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this sbyte value)
     {
         return System.Math.Sign(value);
@@ -244,11 +205,7 @@ public static class SByteExtensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte Wrap(this sbyte value, sbyte low, sbyte high)
     {
         return (sbyte)((long)value).Wrap(low, high);
@@ -261,11 +218,7 @@ public static class SByteExtensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte Wrap(this sbyte value, sbyte length)
     {
         return (sbyte)((long)value).Wrap(length);

X10D/src/Math/SingleExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -20,11 +21,7 @@ public static class SingleExtensions
     ///     is equal to <see cref="float.NaN" />, less than -1, or greater than 1, <see cref="float.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Acos(this float value)
     {
         return MathF.Acos(value);
@@ -42,11 +39,7 @@ public static class SingleExtensions
     ///     <paramref name="value" /> is less than 1 or equal to <see cref="float.NaN" />, <see cref="float.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Acosh(this float value)
     {
         return MathF.Acosh(value);
@@ -64,11 +57,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Asin(this float value)
     {
         return MathF.Asin(value);
@@ -86,11 +75,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" />, <see cref="float.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Asinh(this float value)
     {
         return MathF.Asinh(value);
@@ -107,11 +92,7 @@ public static class SingleExtensions
     ///     <paramref name="value" /> is equal to <see cref="float.NaN" />, <see cref="float.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Atan(this float value)
     {
         return MathF.Atan(value);
@@ -130,11 +111,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Atanh(this float value)
     {
         return MathF.Atanh(value);
@@ -146,11 +123,7 @@ public static class SingleExtensions
     /// <param name="value">The number whose square root is to be found.</param>
     /// <returns>The square root of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Complex ComplexSqrt(this float value)
     {
         switch (value)
@@ -180,11 +153,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Cos(this float value)
     {
         return MathF.Cos(value);
@@ -201,11 +170,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" />, <see cref="double.NaN" /> is returned.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Cosh(this float value)
     {
         return MathF.Cosh(value);
@@ -217,11 +182,7 @@ public static class SingleExtensions
     /// <param name="value">The angle in degrees to convert.</param>
     /// <returns>The result of π * <paramref name="value" /> / 180.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float DegreesToRadians(this float value)
     {
         return value * (MathF.PI / 180.0f);
@@ -236,11 +197,7 @@ public static class SingleExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this float value)
     {
         return value % 2 == 0;
@@ -255,11 +212,7 @@ public static class SingleExtensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this float value)
     {
         return !value.IsEven();
@@ -271,11 +224,7 @@ public static class SingleExtensions
     /// <param name="value">The angle in radians to convert.</param>
     /// <returns>The result of π * <paramref name="value" /> / 180.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float RadiansToDegrees(this float value)
     {
         return value * (180.0f / MathF.PI);
@@ -287,11 +236,7 @@ public static class SingleExtensions
     /// <param name="value">The value to round.</param>
     /// <returns><paramref name="value" /> rounded to the nearest whole number.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Round(this float value)
     {
         return value.Round(1.0f);
@@ -304,11 +249,7 @@ public static class SingleExtensions
     /// <param name="nearest">The nearest multiple to which <paramref name="value" /> should be rounded.</param>
     /// <returns><paramref name="value" /> rounded to the nearest multiple of <paramref name="nearest" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Round(this float value, float nearest)
     {
         return MathF.Round(value / nearest) * nearest;
@@ -321,11 +262,7 @@ public static class SingleExtensions
     /// <returns>The saturated value.</returns>
     /// <remarks>This method clamps <paramref name="value" /> between 0 and 1.</remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Saturate(this float value)
     {
         return System.Math.Clamp(value, 0.0f, 1.0f);
@@ -359,11 +296,7 @@ public static class SingleExtensions
     ///     </list>
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int Sign(this float value)
     {
         return MathF.Sign(value);
@@ -399,11 +332,7 @@ public static class SingleExtensions
     /// <author>SLenik https://stackoverflow.com/a/6755197/1467293</author>
     /// <license>CC BY-SA 3.0</license>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Sqrt(this float value)
     {
         switch (value)
@@ -437,11 +366,7 @@ public static class SingleExtensions
     ///     <see cref="double.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Sin(this float value)
     {
         return MathF.Sin(value);
@@ -457,11 +382,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Sinh(this float value)
     {
         return MathF.Sinh(value);
@@ -477,11 +398,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Tan(this float value)
     {
         return MathF.Sin(value);
@@ -498,11 +415,7 @@ public static class SingleExtensions
     ///     <see cref="float.NaN" />, this method returns <see cref="float.NaN" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Tanh(this float value)
     {
         return MathF.Tanh(value);
@@ -516,11 +429,7 @@ public static class SingleExtensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Wrap(this float value, float low, float high)
     {
         return (float)((double)value).Wrap(low, high);
@@ -533,11 +442,7 @@ public static class SingleExtensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static float Wrap(this float value, float length)
     {
         return (float)((double)value).Wrap(length);

X10D/src/Math/UInt16Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -19,11 +20,7 @@ public static class UInt16Extensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort DigitalRoot(this ushort value)
     {
         var root = (ushort)(value % 9);
@@ -36,11 +33,7 @@ public static class UInt16Extensions
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong Factorial(this ushort value)
     {
         if (value == 0)
@@ -65,11 +58,7 @@ public static class UInt16Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort GreatestCommonFactor(this ushort value, ushort other)
     {
         return (ushort)((long)value).GreatestCommonFactor(other);
@@ -84,11 +73,7 @@ public static class UInt16Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this ushort value)
     {
         return (value & 1) == 0;
@@ -102,11 +87,7 @@ public static class UInt16Extensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this ushort value)
     {
         return ((ulong)value).IsPrime();
@@ -121,11 +102,7 @@ public static class UInt16Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this ushort value)
     {
         return !value.IsEven();
@@ -139,11 +116,7 @@ public static class UInt16Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort LowestCommonMultiple(this ushort value, ushort other)
     {
         return (ushort)((ulong)value).LowestCommonMultiple(other);
@@ -158,11 +131,7 @@ public static class UInt16Extensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this ushort value)
     {
         return ((ulong)value).MultiplicativePersistence();
@@ -176,11 +145,7 @@ public static class UInt16Extensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort Wrap(this ushort value, ushort low, ushort high)
     {
         return (ushort)((ulong)value).Wrap(low, high);
@@ -193,11 +158,7 @@ public static class UInt16Extensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort Wrap(this ushort value, ushort length)
     {
         return (ushort)((ulong)value).Wrap(length);

X10D/src/Math/UInt32Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -19,11 +20,7 @@ public static class UInt32Extensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint DigitalRoot(this uint value)
     {
         uint root = value % 9;
@@ -36,11 +33,7 @@ public static class UInt32Extensions
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong Factorial(this uint value)
     {
         if (value == 0)
@@ -65,11 +58,7 @@ public static class UInt32Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint GreatestCommonFactor(this uint value, uint other)
     {
         return (uint)((long)value).GreatestCommonFactor(other);
@@ -84,11 +73,7 @@ public static class UInt32Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this uint value)
     {
         return (value & 1) == 0;
@@ -102,11 +87,7 @@ public static class UInt32Extensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this uint value)
     {
         return ((ulong)value).IsPrime();
@@ -121,11 +102,7 @@ public static class UInt32Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this uint value)
     {
         return !value.IsEven();
@@ -139,11 +116,7 @@ public static class UInt32Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint LowestCommonMultiple(this uint value, uint other)
     {
         return (uint)((ulong)value).LowestCommonMultiple(other);
@@ -158,11 +131,7 @@ public static class UInt32Extensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this uint value)
     {
         return ((ulong)value).MultiplicativePersistence();
@@ -176,11 +145,7 @@ public static class UInt32Extensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint Wrap(this uint value, uint low, uint high)
     {
         return (uint)((ulong)value).Wrap(low, high);
@@ -193,11 +158,7 @@ public static class UInt32Extensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint Wrap(this uint value, uint length)
     {
         return (uint)((ulong)value).Wrap(length);

X10D/src/Math/UInt64Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Math;
 
@@ -19,11 +20,7 @@ public static class UInt64Extensions
     ///     <para>For example, the digital root of 239 is 5: <c>2 + 3 + 9 = 14</c>, then <c>1 + 4 = 5</c>.</para>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong DigitalRoot(this ulong value)
     {
         ulong root = value % 9;
@@ -36,11 +33,7 @@ public static class UInt64Extensions
     /// <param name="value">The value whose factorial to compute.</param>
     /// <returns>The factorial of <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong Factorial(this ulong value)
     {
         if (value == 0)
@@ -65,11 +58,7 @@ public static class UInt64Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The greatest common factor between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong GreatestCommonFactor(this ulong value, ulong other)
     {
         while (other != 0)
@@ -89,11 +78,7 @@ public static class UInt64Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEven(this ulong value)
     {
         return (value & 1) == 0;
@@ -107,11 +92,7 @@ public static class UInt64Extensions
     ///     <see langword="true" /> if <paramref name="value" /> is prime; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPrime(this ulong value)
     {
         switch (value)
@@ -145,11 +126,7 @@ public static class UInt64Extensions
     ///     otherwise.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOdd(this ulong value)
     {
         return !value.IsEven();
@@ -163,11 +140,7 @@ public static class UInt64Extensions
     /// <param name="other">The second value.</param>
     /// <returns>The lowest common multiple between <paramref name="value" /> and <paramref name="other" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong LowestCommonMultiple(this ulong value, ulong other)
     {
         if (value == 0 || other == 0)
@@ -197,11 +170,7 @@ public static class UInt64Extensions
     ///     Multiplicative persistence is defined as the recursive digital product until that product is a single digit.
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int MultiplicativePersistence(this ulong value)
     {
         var persistence = 0;
@@ -246,11 +215,7 @@ public static class UInt64Extensions
     /// <param name="high">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong Wrap(this ulong value, ulong low, ulong high)
     {
         ulong difference = high - low;
@@ -264,11 +229,7 @@ public static class UInt64Extensions
     /// <param name="length">The exclusive upper bound.</param>
     /// <returns>The wrapped value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong Wrap(this ulong value, ulong length)
     {
         return ((value % length) + length) % length;

X10D/src/Net/EndPointExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Net;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Net;
 
@@ -22,11 +23,7 @@ public static class EndPointExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="endPoint" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string GetHost(this EndPoint endPoint)
     {
 #if NET6_0_OR_GREATER
@@ -59,11 +56,7 @@ public static class EndPointExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="endPoint" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int GetPort(this EndPoint endPoint)
     {
 #if NET6_0_OR_GREATER

X10D/src/Net/IPAddressExtensions.cs

@@ -2,6 +2,7 @@
 using System.Net;
 using System.Net.Sockets;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Net;
 
@@ -19,11 +20,7 @@ public static class IPAddressExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="address" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsIPv4(this IPAddress address)
     {
 #if NET6_0_OR_GREATER
@@ -47,11 +44,7 @@ public static class IPAddressExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="address" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsIPv6(this IPAddress address)
     {
 #if NET6_0_OR_GREATER

X10D/src/Net/Int16Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Net;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Net;
 
@@ -15,11 +16,7 @@ public static class Int16Extensions
     /// <param name="value">The value to convert, expressed in host byte order.</param>
     /// <returns>An integer value, expressed in network byte order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short HostToNetworkOrder(this short value)
     {
         return IPAddress.HostToNetworkOrder(value);
@@ -31,11 +28,7 @@ public static class Int16Extensions
     /// <param name="value">The value to convert, expressed in network byte order.</param>
     /// <returns>An integer value, expressed in host byte order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short NetworkToHostOrder(this short value)
     {
         return IPAddress.NetworkToHostOrder(value);

X10D/src/Net/Int32Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Net;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Net;
 
@@ -15,11 +16,7 @@ public static class Int32Extensions
     /// <param name="value">The value to convert, expressed in host byte order.</param>
     /// <returns>An integer value, expressed in network byte order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int HostToNetworkOrder(this int value)
     {
         return IPAddress.HostToNetworkOrder(value);
@@ -31,11 +28,7 @@ public static class Int32Extensions
     /// <param name="value">The value to convert, expressed in network byte order.</param>
     /// <returns>An integer value, expressed in host byte order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int NetworkToHostOrder(this int value)
     {
         return IPAddress.NetworkToHostOrder(value);

X10D/src/Net/Int64Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Net;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Net;
 
@@ -15,11 +16,7 @@ public static class Int64Extensions
     /// <param name="value">The value to convert, expressed in host byte order.</param>
     /// <returns>An integer value, expressed in network byte order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long HostToNetworkOrder(this long value)
     {
         return IPAddress.HostToNetworkOrder(value);
@@ -31,11 +28,7 @@ public static class Int64Extensions
     /// <param name="value">The value to convert, expressed in network byte order.</param>
     /// <returns>An integer value, expressed in host byte order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long NetworkToHostOrder(this long value)
     {
         return IPAddress.NetworkToHostOrder(value);

X10D/src/Numerics/ByteExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Numerics;
@@ -19,11 +20,7 @@ public static class ByteExtensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this byte value)
     {
         return ((uint)value).PopCount();
@@ -38,11 +35,7 @@ public static class ByteExtensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte RotateLeft(this byte value, int count)
     {
         count = count.Mod(8);
@@ -58,11 +51,7 @@ public static class ByteExtensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte RotateRight(this byte value, int count)
     {
         count = count.Mod(8);
@@ -78,11 +67,7 @@ public static class ByteExtensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte RoundUpToPowerOf2(this byte value)
     {
         return (byte)((uint)value).RoundUpToPowerOf2();

X10D/src/Numerics/Int16Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -18,11 +19,7 @@ public static class Int16Extensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this short value)
     {
         return ((uint)value).PopCount();
@@ -37,11 +34,7 @@ public static class Int16Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short RotateLeft(this short value, int count)
     {
         var unsigned = unchecked((ushort)value);
@@ -57,11 +50,7 @@ public static class Int16Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short RotateRight(this short value, int count)
     {
         var unsigned = unchecked((ushort)value);
@@ -77,11 +66,7 @@ public static class Int16Extensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static short RoundUpToPowerOf2(this short value)
     {
         return (short)((uint)value).RoundUpToPowerOf2();

X10D/src/Numerics/Int32Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -18,11 +19,7 @@ public static class Int32Extensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this int value)
     {
         return ((uint)value).PopCount();
@@ -37,11 +34,7 @@ public static class Int32Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int RotateLeft(this int value, int count)
     {
         var unsigned = unchecked((uint)value);
@@ -57,11 +50,7 @@ public static class Int32Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int RotateRight(this int value, int count)
     {
         var unsigned = unchecked((uint)value);
@@ -77,11 +66,7 @@ public static class Int32Extensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int RoundUpToPowerOf2(this int value)
     {
         return (int)((uint)value).RoundUpToPowerOf2();

X10D/src/Numerics/Int64Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -18,11 +19,7 @@ public static class Int64Extensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this long value)
     {
         return ((ulong)value).PopCount();
@@ -37,11 +34,7 @@ public static class Int64Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long RotateLeft(this long value, int count)
     {
         var unsigned = unchecked((ulong)value);
@@ -57,11 +50,7 @@ public static class Int64Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long RotateRight(this long value, int count)
     {
         var unsigned = unchecked((ulong)value);
@@ -77,11 +66,7 @@ public static class Int64Extensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long RoundUpToPowerOf2(this long value)
     {
         return (long)((ulong)value).RoundUpToPowerOf2();

X10D/src/Numerics/SByteExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -19,11 +20,7 @@ public static class SByteExtensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this sbyte value)
     {
         return ((uint)value).PopCount();
@@ -38,11 +35,7 @@ public static class SByteExtensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte RotateLeft(this sbyte value, int count)
     {
         var signed = unchecked((byte)value);
@@ -58,11 +51,7 @@ public static class SByteExtensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte RotateRight(this sbyte value, int count)
     {
         var signed = unchecked((byte)value);
@@ -78,11 +67,7 @@ public static class SByteExtensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static sbyte RoundUpToPowerOf2(this sbyte value)
     {
         return (sbyte)((uint)value).RoundUpToPowerOf2();

X10D/src/Numerics/UInt16Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -19,11 +20,7 @@ public static class UInt16Extensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this ushort value)
     {
         return ((uint)value).PopCount();
@@ -38,11 +35,7 @@ public static class UInt16Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort RotateLeft(this ushort value, int count)
     {
         return (ushort)((ushort)(value << count) | (ushort)(value >> (16 - count)));
@@ -57,11 +50,7 @@ public static class UInt16Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort RotateRight(this ushort value, int count)
     {
         return (ushort)((ushort)(value >> count) | (ushort)(value << (16 - count)));
@@ -76,11 +65,7 @@ public static class UInt16Extensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ushort RoundUpToPowerOf2(this ushort value)
     {
         return (ushort)((uint)value).RoundUpToPowerOf2();

X10D/src/Numerics/UInt32Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -20,11 +21,7 @@ public static class UInt32Extensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this uint value)
     {
 #if NETCOREAPP3_1_OR_GREATER
@@ -52,11 +49,7 @@ public static class UInt32Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint RotateLeft(this uint value, int count)
     {
         return (value << count) | (value >> (32 - count));
@@ -71,11 +64,7 @@ public static class UInt32Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint RotateRight(this uint value, int count)
     {
         return (value >> count) | (value << (32 - count));
@@ -90,11 +79,7 @@ public static class UInt32Extensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static uint RoundUpToPowerOf2(this uint value)
     {
 #if NET6_0_OR_GREATER

X10D/src/Numerics/UInt64Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Numerics;
 
@@ -20,11 +21,7 @@ public static class UInt64Extensions
     ///     <a href="https://docs.microsoft.com/en-us/dotnet/api/system.runtime.intrinsics.x86.popcnt?view=net-6.0">POPCNT</a>
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static int PopCount(this ulong value)
     {
 #if NETCOREAPP3_1_OR_GREATER
@@ -52,11 +49,7 @@ public static class UInt64Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong RotateLeft(this ulong value, int count)
     {
         return (value << count) | (value >> (64 - count));
@@ -71,11 +64,7 @@ public static class UInt64Extensions
     /// </param>
     /// <returns>The rotated value.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong RotateRight(this ulong value, int count)
     {
         return (value >> count) | (value << (64 - count));
@@ -90,11 +79,7 @@ public static class UInt64Extensions
     ///     is 0 or the result overflows.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static ulong RoundUpToPowerOf2(this ulong value)
     {
 #if NET6_0_OR_GREATER

X10D/src/Numerics/Vector2Extensions.cs

@@ -2,6 +2,7 @@
 using System.Drawing;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Drawing;
 using X10D.Math;
 
@@ -34,11 +35,7 @@ public static class Vector2Extensions
     ///     <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this Vector2 point, LineF line)
     {
         (float x1, float x2) = (line.Start.X, line.End.X);
@@ -58,11 +55,7 @@ public static class Vector2Extensions
     ///     <paramref name="end" />; otherwise <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this Vector2 point, PointF start, PointF end)
     {
         return point.IsOnLine(new LineF(start, end));
@@ -79,11 +72,7 @@ public static class Vector2Extensions
     ///     <paramref name="end" />; otherwise <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsOnLine(this Vector2 point, Vector2 start, Vector2 end)
     {
         return point.IsOnLine(new LineF(start, end));
@@ -95,11 +84,7 @@ public static class Vector2Extensions
     /// <param name="vector">The vector whose components to round.</param>
     /// <returns>The rounded vector.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector2 Round(this Vector2 vector)
     {
         return vector.Round(1.0f);
@@ -112,11 +97,7 @@ public static class Vector2Extensions
     /// <param name="nearest">The nearest multiple to which the components should be rounded.</param>
     /// <returns>The rounded vector.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector2 Round(this Vector2 vector, float nearest)
     {
         float x = vector.X.Round(nearest);
@@ -130,11 +111,7 @@ public static class Vector2Extensions
     /// <param name="vector">The vector to convert.</param>
     /// <returns>The resulting <see cref="PointF" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static PointF ToPointF(this Vector2 vector)
     {
         return new PointF(vector.X, vector.Y);
@@ -146,11 +123,7 @@ public static class Vector2Extensions
     /// <param name="vector">The vector to convert.</param>
     /// <returns>The resulting <see cref="SizeF" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static SizeF ToSizeF(this Vector2 vector)
     {
         return new SizeF(vector.X, vector.Y);
@@ -166,11 +139,7 @@ public static class Vector2Extensions
     ///     <paramref name="vector" />, and whose <see cref="Vector2.X" /> component is <paramref name="x" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector2 WithX(this Vector2 vector, float x)
     {
         return vector with {X = x};
@@ -186,11 +155,7 @@ public static class Vector2Extensions
     ///     <paramref name="vector" />, and whose <see cref="Vector2.Y" /> component is <paramref name="y" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector2 WithY(this Vector2 vector, float y)
     {
         return vector with {Y = y};

X10D/src/Numerics/Vector3Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Numerics;
@@ -30,11 +31,7 @@ public static class Vector3Extensions
     /// <param name="vector">The vector whose components to round.</param>
     /// <returns>The rounded vector.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector3 Round(this Vector3 vector)
     {
         return vector.Round(1.0f);
@@ -47,11 +44,7 @@ public static class Vector3Extensions
     /// <param name="nearest">The nearest multiple to which the components should be rounded.</param>
     /// <returns>The rounded vector.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector3 Round(this Vector3 vector, float nearest)
     {
         float x = vector.X.Round(nearest);
@@ -70,11 +63,7 @@ public static class Vector3Extensions
     ///     the same as that of <paramref name="vector" />, and whose <see cref="Vector3.Y" /> component is <paramref name="x" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector3 WithX(this Vector3 vector, float x)
     {
         return vector with {X = x};
@@ -90,11 +79,7 @@ public static class Vector3Extensions
     ///     the same as that of <paramref name="vector" />, and whose <see cref="Vector3.Y" /> component is <paramref name="y" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector3 WithY(this Vector3 vector, float y)
     {
         return vector with {Y = y};
@@ -110,11 +95,7 @@ public static class Vector3Extensions
     ///     the same as that of <paramref name="vector" />, and whose <see cref="Vector3.Z" /> component is <paramref name="z" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector3 WithZ(this Vector3 vector, float z)
     {
         return vector with {Z = z};

X10D/src/Numerics/Vector4Extensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Numerics;
@@ -32,11 +33,7 @@ public static class Vector4Extensions
     /// <param name="vector">The vector whose components to round.</param>
     /// <returns>The rounded vector.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector4 Round(this Vector4 vector)
     {
         return vector.Round(1.0f);
@@ -49,11 +46,7 @@ public static class Vector4Extensions
     /// <param name="nearest">The nearest multiple to which the components should be rounded.</param>
     /// <returns>The rounded vector.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector4 Round(this Vector4 vector, float nearest)
     {
         float x = vector.X.Round(nearest);
@@ -75,11 +68,7 @@ public static class Vector4Extensions
     ///     <see cref="Vector4.X" /> component is <paramref name="x" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector4 WithX(this Vector4 vector, float x)
     {
         return vector with {X = x};
@@ -97,11 +86,7 @@ public static class Vector4Extensions
     ///     <see cref="Vector4.Y" /> component is <paramref name="y" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector4 WithY(this Vector4 vector, float y)
     {
         return vector with {Y = y};
@@ -119,11 +104,7 @@ public static class Vector4Extensions
     ///     <see cref="Vector4.Z" /> component is <paramref name="z" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector4 WithZ(this Vector4 vector, float z)
     {
         return vector with {Z = z};
@@ -141,11 +122,7 @@ public static class Vector4Extensions
     ///     <see cref="Vector4.W" /> component is <paramref name="w" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static Vector4 WithW(this Vector4 vector, float w)
     {
         return vector with {W = w};

X10D/src/Reflection/MemberInfoExtensions.cs

@@ -2,6 +2,7 @@
 using System.Globalization;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Reflection;
 
@@ -21,11 +22,7 @@ public static class MemberInfoExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="member" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool HasCustomAttribute<T>(this MemberInfo member)
         where T : Attribute
     {
@@ -51,11 +48,7 @@ public static class MemberInfoExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="member" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool HasCustomAttribute(this MemberInfo member, Type attribute)
     {
 #if NET6_0_OR_GREATER

X10D/src/Reflection/TypeExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.Contracts;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Reflection;
 
@@ -17,11 +18,7 @@ public static class TypeExtensions
     /// <returns><see langword="true" /> if the current exists on the type; otherwise, <see langword="false" />.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Implements<T>(this Type value)
     {
 #if NET6_0_OR_GREATER
@@ -48,11 +45,7 @@ public static class TypeExtensions
     ///     <para><paramref name="interfaceType" /> is <see langword="null" />.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Implements(this Type value, Type interfaceType)
     {
 #if NET6_0_OR_GREATER
@@ -93,11 +86,7 @@ public static class TypeExtensions
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     /// <exception cref="ArgumentException"><paramref name="value" /> is not a class.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Inherits<T>(this Type value)
         where T : class
     {
@@ -133,11 +122,7 @@ public static class TypeExtensions
     ///     <para><paramref name="type" /> is not a class.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool Inherits(this Type value, Type type)
     {
 #if NET6_0_OR_GREATER

X10D/src/Text/CharExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Text;
 
@@ -14,11 +15,7 @@ public static class CharExtensions
     /// <param name="value">The character to check.</param>
     /// <returns><see langword="true" /> if this character is an emoji; otherwise, <see langword="false" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEmoji(this char value)
     {
         return value.ToString().IsEmoji();
@@ -33,11 +30,7 @@ public static class CharExtensions
     ///     A <see cref="string" /> composed of <paramref name="value" /> repeated <paramref name="count" /> times.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Repeat(this char value, int count)
     {
         return count switch

X10D/src/Text/Extensions.cs

@@ -2,6 +2,7 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using X10D.CompilerServices;
 
 namespace X10D.Text;
 
@@ -18,7 +19,7 @@ public static class Extensions
     /// <typeparam name="T">The type of the value to convert.</typeparam>
     /// <returns>A JSON string representing the object.</returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string ToJson<T>(this T value, JsonSerializerOptions? options = null)
     {
         return JsonSerializer.Serialize(value, options);

X10D/src/Text/RuneExtensions.cs

@@ -5,6 +5,7 @@ using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
+using X10D.CompilerServices;
 
 namespace X10D.Text;
 
@@ -19,7 +20,7 @@ public static class RuneExtensions
     /// <param name="value">The rune to check.</param>
     /// <returns><see langword="true" /> if this rune is an emoji; otherwise, <see langword="false" />.</returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEmoji(this Rune value)
     {
         return value.ToString().IsEmoji();
@@ -34,7 +35,7 @@ public static class RuneExtensions
     ///     A <see cref="string" /> composed of <paramref name="value" /> repeated <paramref name="count" /> times.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Repeat(this Rune value, int count)
     {
         switch (count)

X10D/src/Text/StringExtensions.cs

@@ -6,6 +6,7 @@ using System.Text;
 using System.Text.Json;
 #endif
 using X10D.Collections;
+using X10D.CompilerServices;
 using X10D.Core;
 using X10D.IO;
 
@@ -25,11 +26,7 @@ public static class StringExtensions
     ///     <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [return: NotNullIfNotNull("value")]
     public static string? AsNullIfEmpty(this string? value)
     {
@@ -46,11 +43,7 @@ public static class StringExtensions
     ///     whitespace; otherwise, <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [return: NotNullIfNotNull("value")]
     public static string? AsNullIfWhiteSpace(this string? value)
     {
@@ -64,11 +57,7 @@ public static class StringExtensions
     /// <returns>The plain text string representation of <paramref name="value" />.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Base64Decode(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -90,11 +79,7 @@ public static class StringExtensions
     /// <returns>The string representation, in base 64, of <paramref name="value" />.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Base64Encode(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -127,11 +112,7 @@ public static class StringExtensions
     ///     <paramref name="destinationEncoding" /> is <see langword="null" />.
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string ChangeEncoding(this string value, Encoding sourceEncoding, Encoding destinationEncoding)
     {
 #if NET6_0_OR_GREATER
@@ -370,11 +351,7 @@ public static class StringExtensions
     ///     (http://geekswithblogs.net/sdorman/Default.aspx).
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static T EnumParse<T>(this string value)
         where T : struct, Enum
     {
@@ -393,11 +370,7 @@ public static class StringExtensions
     ///     (http://geekswithblogs.net/sdorman/Default.aspx).
     /// </remarks>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static T EnumParse<T>(this string value, bool ignoreCase)
         where T : struct, Enum
     {
@@ -444,11 +417,7 @@ public static class StringExtensions
     /// <param name="value">The string to convert.</param>
     /// <returns>Returns a <see cref="byte" />[].</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte[] GetBytes(this string value)
     {
         return value.GetBytes(Encoding.UTF8);
@@ -465,11 +434,7 @@ public static class StringExtensions
     ///     <see langword="null" />.
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static byte[] GetBytes(this string value, Encoding encoding)
     {
 #if NET6_0_OR_GREATER
@@ -496,11 +461,7 @@ public static class StringExtensions
     /// <param name="value">The input string.</param>
     /// <returns><see langword="true" /> if this string is an emoji; otherwise, <see langword="false" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEmoji(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -524,11 +485,7 @@ public static class StringExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsEmpty(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -552,11 +509,7 @@ public static class StringExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLower(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -610,11 +563,7 @@ public static class StringExtensions
     ///     <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsNullOrEmpty([NotNullWhen(false)] this string? value)
     {
         return string.IsNullOrEmpty(value);
@@ -630,11 +579,7 @@ public static class StringExtensions
     ///     whitespace; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsNullOrWhiteSpace([NotNullWhen(false)] this string? value)
     {
         return string.IsNullOrWhiteSpace(value);
@@ -651,11 +596,7 @@ public static class StringExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsPalindrome(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -729,11 +670,7 @@ public static class StringExtensions
     ///     <see langword="true" /> if all alpha characters in this string are uppercase; otherwise, <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsUpper(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -788,11 +725,7 @@ public static class StringExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsWhiteSpace(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -829,11 +762,7 @@ public static class StringExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Repeat(this string value, int count)
     {
 #if NET6_0_OR_GREATER
@@ -878,11 +807,7 @@ public static class StringExtensions
     /// <exception cref="ArgumentNullException"><paramref name="source" /> is <see langword="null" />.</exception>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="length" /> is less than 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Randomize(this string source, int length, Random? random = null)
     {
 #if NET6_0_OR_GREATER
@@ -924,11 +849,7 @@ public static class StringExtensions
     /// <param name="value">The string to reverse.</param>
     /// <returns>A <see cref="string" /> whose characters are that of <paramref name="value" /> in reverse order.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Reverse(this string value)
     {
 #if NET6_0_OR_GREATER
@@ -966,11 +887,7 @@ public static class StringExtensions
     /// <returns>A new <see cref="string" /> containing the characters in <paramref name="value" />, rearranged.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static string Shuffled(this string value, Random? random = null)
     {
 #if NET6_0_OR_GREATER
@@ -1000,11 +917,7 @@ public static class StringExtensions
     /// </returns>
     /// <exception cref="ArgumentNullException"><paramref name="value" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static IEnumerable<string> Split(this string value, int chunkSize)
     {
 #if NET6_0_OR_GREATER
@@ -1116,11 +1029,7 @@ public static class StringExtensions
     ///     <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [return: NotNullIfNotNull("alternative")]
     public static string? WithEmptyAlternative(this string? value, string? alternative)
     {
@@ -1138,11 +1047,7 @@ public static class StringExtensions
     ///     whitespace; otherwise, <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [return: NotNullIfNotNull("alternative")]
     public static string? WithWhiteSpaceAlternative(this string? value, string? alternative)
     {

X10D/src/Time/ByteExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -17,11 +18,7 @@ public static class ByteExtensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this byte value)
     {
         if (value == 0)
@@ -47,11 +44,7 @@ public static class ByteExtensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this byte value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -72,11 +65,7 @@ public static class ByteExtensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this byte value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -88,11 +77,7 @@ public static class ByteExtensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this byte value)
     {
         return TimeSpan.FromTicks(value);
@@ -106,11 +91,7 @@ public static class ByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this byte value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -124,11 +105,7 @@ public static class ByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this byte value)
     {
         return TimeSpan.FromSeconds(value);
@@ -142,11 +119,7 @@ public static class ByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this byte value)
     {
         return TimeSpan.FromMinutes(value);
@@ -160,11 +133,7 @@ public static class ByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this byte value)
     {
         return TimeSpan.FromHours(value);
@@ -176,11 +145,7 @@ public static class ByteExtensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this byte value)
     {
         return TimeSpan.FromDays(value);
@@ -194,11 +159,7 @@ public static class ByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this byte value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/CharSpanExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -57,11 +58,7 @@ public static class CharSpanExtensions
     /// </param>
     /// <returns>A new instance of <see cref="TimeSpan" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan ToTimeSpan(this ReadOnlySpan<char> input)
     {
         return TimeSpanParser.TryParse(input, out TimeSpan result) ? result : default;

X10D/src/Time/DateOnlyExtensions.cs

@@ -0,0 +1,201 @@
+#if NET6_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
+
+namespace X10D.Time;
+
+/// <summary>
+///     Time-related extension methods for <see cref="DateOnly" />.
+/// </summary>
+public static class DateOnlyExtensions
+{
+    /// <summary>
+    ///     Returns the rounded-down integer number of years since a given date as of today.
+    /// </summary>
+    /// <param name="value">The date from which to calculate.</param>
+    /// <returns>The rounded-down integer number of years since <paramref name="value" /> as of today.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    [ExcludeFromCodeCoverage]
+    public static int Age(this DateOnly value)
+    {
+        return value.Age(DateOnly.FromDateTime(DateTime.Today));
+    }
+
+    /// <summary>
+    ///     Returns the rounded-down integer number of years since a given date as of another specified date.
+    /// </summary>
+    /// <param name="value">The date from which to calculate.</param>
+    /// <param name="referenceDate">The date to use as the calculation reference.</param>
+    /// <returns>
+    ///     The rounded-down integer number of years since <paramref name="value" /> as of the date specified by
+    ///     <paramref name="referenceDate" />.
+    /// </returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static int Age(this DateOnly value, DateOnly referenceDate)
+    {
+        return value.ToDateTime(default).Age(referenceDate.ToDateTime(default));
+    }
+
+    /// <summary>
+    ///     Deconstructs the current <see cref="DateOnly" /> into its year, month, and day.
+    /// </summary>
+    /// <param name="value">The date to deconstruct.</param>
+    /// <param name="year">When this method returns, contains the year.</param>
+    /// <param name="month">When this method returns, contains the month.</param>
+    /// <param name="day">When this method returns, contains the day.</param>
+    public static void Deconstruct(this DateOnly value, out int year, out int month, out int day)
+    {
+        year = value.Year;
+        month = value.Month;
+        day = value.Day;
+    }
+
+    /// <summary>
+    ///     Gets a date representing the first occurence of a specified day of the week in the current month.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <param name="dayOfWeek">The day of the week.</param>
+    /// <returns>A <see cref="DateTimeOffset" /> representing the first occurence of <paramref name="dayOfWeek" />.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static DateOnly First(this DateOnly value, DayOfWeek dayOfWeek)
+    {
+        DateOnly first = value.FirstDayOfMonth();
+
+        if (first.DayOfWeek != dayOfWeek)
+        {
+            first = first.Next(dayOfWeek);
+        }
+
+        return first;
+    }
+
+    /// <summary>
+    ///     Gets a date representing the first day of the current month.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <returns>A <see cref="DateTimeOffset" /> representing the first day of the current month.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static DateOnly FirstDayOfMonth(this DateOnly value)
+    {
+        return value.AddDays(1 - value.Day);
+    }
+
+    /// <summary>
+    ///     Gets the ISO-8601 week number of the year for the current date.
+    /// </summary>
+    /// <param name="value">The date whose week number to return.</param>
+    /// <returns>The ISO-8601 week number of the year.</returns>
+    /// <author>Shawn Steele, Microsoft</author>
+    /// <remarks>
+    ///     This implementation is directly inspired from a
+    ///     <a href="https://docs.microsoft.com/en-gb/archive/blogs/shawnste/iso-8601-week-of-year-format-in-microsoft-net">
+    ///         blog post
+    ///     </a>.
+    ///     about this subject.
+    /// </remarks>
+    [Pure]
+    public static int GetIso8601WeekOfYear(this DateOnly value)
+    {
+        return value.ToDateTime(default).GetIso8601WeekOfYear();
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether the year represented by the current <see cref="DateOnly" /> is a leap year.
+    /// </summary>
+    /// <param name="value">The date whose year to check.</param>
+    /// <returns>
+    ///     <see langword="true" /> if the year represented by <paramref name="value" /> is a leap year; otherwise,
+    ///     <see langword="false" />.
+    /// </returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static bool IsLeapYear(this DateOnly value)
+    {
+        return DateTime.IsLeapYear(value.Year);
+    }
+
+    /// <summary>
+    ///     Gets a date representing the final occurence of a specified day of the week in the current month.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <param name="dayOfWeek">The day of the week.</param>
+    /// <returns>A <see cref="DateTimeOffset" /> representing the final occurence of <paramref name="dayOfWeek" />.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static DateOnly Last(this DateOnly value, DayOfWeek dayOfWeek)
+    {
+        DateOnly last = value.LastDayOfMonth();
+        var lastDayOfWeek = last.DayOfWeek;
+
+        int diff = dayOfWeek - lastDayOfWeek;
+        int offset = diff > 0 ? diff - 7 : diff;
+
+        return last.AddDays(offset);
+    }
+
+    /// <summary>
+    ///     Gets a date representing the last day of the current month.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <returns>A <see cref="DateTimeOffset" /> representing the last day of the current month.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static DateOnly LastDayOfMonth(this DateOnly value)
+    {
+        int daysInMonth = DateTime.DaysInMonth(value.Year, value.Month);
+        return new DateOnly(value.Year, value.Month, daysInMonth);
+    }
+
+    /// <summary>
+    ///     Gets a date representing the next occurence of a specified day of the week in the current month.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <param name="dayOfWeek">The day of the week.</param>
+    /// <returns>A <see cref="DateTimeOffset" /> representing the next occurence of <paramref name="dayOfWeek" />.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static DateOnly Next(this DateOnly value, DayOfWeek dayOfWeek)
+    {
+        int offsetDays = dayOfWeek - value.DayOfWeek;
+
+        if (offsetDays <= 0)
+        {
+            offsetDays += 7;
+        }
+
+        return value.AddDays(offsetDays);
+    }
+
+    /// <summary>
+    ///     Returns the number of milliseconds that have elapsed since 1970-01-01T00:00:00.000Z.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <param name="time">A reference time to use with the current date.</param>
+    /// <returns>The number of milliseconds that have elapsed since 1970-01-01T00:00:00.000Z.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static long ToUnixTimeMilliseconds(this DateOnly value, TimeOnly time)
+    {
+        return value.ToDateTime(time).ToUnixTimeMilliseconds();
+    }
+
+    /// <summary>
+    ///     Returns the number of seconds that have elapsed since 1970-01-01T00:00:00.000Z.
+    /// </summary>
+    /// <param name="value">The current date.</param>
+    /// <param name="time">A reference time to use with the current date.</param>
+    /// <returns>The number of seconds that have elapsed since 1970-01-01T00:00:00.000Z.</returns>
+    [Pure]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static long ToUnixTimeSeconds(this DateOnly value, TimeOnly time)
+    {
+        return value.ToDateTime(time).ToUnixTimeSeconds();
+    }
+}
+#endif

X10D/src/Time/DateTimeExtensions.cs

@@ -2,6 +2,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Globalization;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -12,11 +13,7 @@ public static class DateTimeExtensions
 {
     /// <inheritdoc cref="DateTimeOffsetExtensions.Age(DateTimeOffset)" />
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static int Age(this DateTime value)
     {
@@ -25,24 +22,16 @@ public static class DateTimeExtensions
 
     /// <inheritdoc cref="DateTimeOffsetExtensions.Age(DateTimeOffset, DateTimeOffset)" />
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
-    public static int Age(this DateTime value, DateTime asOf)
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static int Age(this DateTime value, DateTime referenceDate)
     {
-        return ((DateTimeOffset)value).Age(asOf);
+        return ((DateTimeOffset)value).Age(referenceDate);
     }
 
     /// <inheritdoc cref="DateTimeOffsetExtensions.First(DateTimeOffset, DayOfWeek)" />
     /// <returns>A <see cref="DateTime" /> representing the first occurence of <paramref name="dayOfWeek" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime First(this DateTime value, DayOfWeek dayOfWeek)
     {
         return ((DateTimeOffset)value).First(dayOfWeek).DateTime;
@@ -51,11 +40,7 @@ public static class DateTimeExtensions
     /// <inheritdoc cref="DateTimeOffsetExtensions.FirstDayOfMonth(DateTimeOffset)" />
     /// <returns>A <see cref="DateTime" /> representing the first day of the current month.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime FirstDayOfMonth(this DateTime value)
     {
         return ((DateTimeOffset)value).FirstDayOfMonth().DateTime;
@@ -96,11 +81,7 @@ public static class DateTimeExtensions
     ///     <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this DateTime value)
     {
         return DateTime.IsLeapYear(value.Year);
@@ -109,11 +90,7 @@ public static class DateTimeExtensions
     /// <inheritdoc cref="DateTimeOffsetExtensions.Last(DateTimeOffset, DayOfWeek)" />
     /// <returns>A <see cref="DateTimeOffset" /> representing the final occurence of <paramref name="dayOfWeek" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime Last(this DateTime value, DayOfWeek dayOfWeek)
     {
         return ((DateTimeOffset)value).Last(dayOfWeek).DateTime;
@@ -122,11 +99,7 @@ public static class DateTimeExtensions
     /// <inheritdoc cref="DateTimeOffsetExtensions.LastDayOfMonth(DateTimeOffset)" />
     /// <returns>A <see cref="DateTimeOffset" /> representing the last day of the current month.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime LastDayOfMonth(this DateTime value)
     {
         return ((DateTimeOffset)value).LastDayOfMonth().DateTime;
@@ -135,11 +108,7 @@ public static class DateTimeExtensions
     /// <inheritdoc cref="DateTimeOffsetExtensions.Next(DateTimeOffset, DayOfWeek)" />
     /// <returns>A <see cref="DateTimeOffset" /> representing the next occurence of <paramref name="dayOfWeek" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime Next(this DateTime value, DayOfWeek dayOfWeek)
     {
         return ((DateTimeOffset)value).Next(dayOfWeek).DateTime;
@@ -151,11 +120,7 @@ public static class DateTimeExtensions
     /// <param name="value">The current date.</param>
     /// <returns>The number of milliseconds that have elapsed since 1970-01-01T00:00:00.000Z.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long ToUnixTimeMilliseconds(this DateTime value)
     {
         return ((DateTimeOffset)value).ToUnixTimeMilliseconds();
@@ -167,11 +132,7 @@ public static class DateTimeExtensions
     /// <param name="value">The current date.</param>
     /// <returns>The number of seconds that have elapsed since 1970-01-01T00:00:00.000Z.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static long ToUnixTimeSeconds(this DateTime value)
     {
         return ((DateTimeOffset)value).ToUnixTimeSeconds();

X10D/src/Time/DateTimeOffsetExtensions.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -15,11 +16,7 @@ public static class DateTimeOffsetExtensions
     /// <param name="value">The date from which to calculate.</param>
     /// <returns>The rounded-down integer number of years since <paramref name="value" /> as of today.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     [ExcludeFromCodeCoverage]
     public static int Age(this DateTimeOffset value)
     {
@@ -30,20 +27,16 @@ public static class DateTimeOffsetExtensions
     ///     Returns the rounded-down integer number of years since a given date as of another specified date.
     /// </summary>
     /// <param name="value">The date from which to calculate.</param>
-    /// <param name="asOf">The date at which to stop calculating.</param>
+    /// <param name="referenceDate">The date to use as the calculation reference.</param>
     /// <returns>
     ///     The rounded-down integer number of years since <paramref name="value" /> as of the date specified by
-    ///     <paramref name="asOf" />.
+    ///     <paramref name="referenceDate" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
-    public static int Age(this DateTimeOffset value, DateTimeOffset asOf)
+    [MethodImpl(CompilerResources.MethodImplOptions)]
+    public static int Age(this DateTimeOffset value, DateTimeOffset referenceDate)
     {
-        return (int)(((asOf.Date - TimeSpan.FromDays(1) - value.Date).TotalDays + 1) / 365.2425);
+        return (int)(((referenceDate.Date - TimeSpan.FromDays(1) - value.Date).TotalDays + 1) / 365.2425);
     }
 
     /// <summary>
@@ -53,11 +46,7 @@ public static class DateTimeOffsetExtensions
     /// <param name="dayOfWeek">The day of the week.</param>
     /// <returns>A <see cref="DateTimeOffset" /> representing the first occurence of <paramref name="dayOfWeek" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset First(this DateTimeOffset value, DayOfWeek dayOfWeek)
     {
         var first = value.FirstDayOfMonth();
@@ -76,11 +65,7 @@ public static class DateTimeOffsetExtensions
     /// <param name="value">The current date.</param>
     /// <returns>A <see cref="DateTimeOffset" /> representing the first day of the current month.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FirstDayOfMonth(this DateTimeOffset value)
     {
         return value.AddDays(1 - value.Day);
@@ -114,11 +99,7 @@ public static class DateTimeOffsetExtensions
     ///     <see langword="false" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this DateTimeOffset value)
     {
         return DateTime.IsLeapYear(value.Year);
@@ -131,11 +112,7 @@ public static class DateTimeOffsetExtensions
     /// <param name="dayOfWeek">The day of the week.</param>
     /// <returns>A <see cref="DateTimeOffset" /> representing the final occurence of <paramref name="dayOfWeek" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset Last(this DateTimeOffset value, DayOfWeek dayOfWeek)
     {
         var last = value.LastDayOfMonth();
@@ -153,11 +130,7 @@ public static class DateTimeOffsetExtensions
     /// <param name="value">The current date.</param>
     /// <returns>A <see cref="DateTimeOffset" /> representing the last day of the current month.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset LastDayOfMonth(this DateTimeOffset value)
     {
         int daysInMonth = DateTime.DaysInMonth(value.Year, value.Month);
@@ -171,11 +144,7 @@ public static class DateTimeOffsetExtensions
     /// <param name="dayOfWeek">The day of the week.</param>
     /// <returns>A <see cref="DateTimeOffset" /> representing the next occurence of <paramref name="dayOfWeek" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset Next(this DateTimeOffset value, DayOfWeek dayOfWeek)
     {
         int offsetDays = dayOfWeek - value.DayOfWeek;

X10D/src/Time/DecimalExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -16,11 +17,7 @@ public static class DecimalExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this decimal value)
     {
         return TimeSpan.FromMilliseconds((double)value);
@@ -34,11 +31,7 @@ public static class DecimalExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this decimal value)
     {
         return TimeSpan.FromSeconds((double)value);
@@ -52,11 +45,7 @@ public static class DecimalExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this decimal value)
     {
         return TimeSpan.FromMinutes((double)value);
@@ -70,11 +59,7 @@ public static class DecimalExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this decimal value)
     {
         return TimeSpan.FromHours((double)value);
@@ -86,11 +71,7 @@ public static class DecimalExtensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this decimal value)
     {
         return TimeSpan.FromDays((double)value);
@@ -104,11 +85,7 @@ public static class DecimalExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this decimal value)
     {
         return TimeSpan.FromDays((double)value * 7);

X10D/src/Time/DoubleExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -16,11 +17,7 @@ public static class DoubleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this double value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -34,11 +31,7 @@ public static class DoubleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this double value)
     {
         return TimeSpan.FromSeconds(value);
@@ -52,11 +45,7 @@ public static class DoubleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this double value)
     {
         return TimeSpan.FromMinutes(value);
@@ -70,11 +59,7 @@ public static class DoubleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this double value)
     {
         return TimeSpan.FromHours(value);
@@ -86,11 +71,7 @@ public static class DoubleExtensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this double value)
     {
         return TimeSpan.FromDays(value);
@@ -104,11 +85,7 @@ public static class DoubleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this double value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/HalfExtensions.cs

@@ -1,6 +1,7 @@
 #if NET5_0_OR_GREATER
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -17,7 +18,7 @@ public static class HalfExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this Half value)
     {
         return TimeSpan.FromMilliseconds((float)value);
@@ -31,7 +32,7 @@ public static class HalfExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this Half value)
     {
         return TimeSpan.FromSeconds((float)value);
@@ -45,7 +46,7 @@ public static class HalfExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this Half value)
     {
         return TimeSpan.FromMinutes((float)value);
@@ -59,7 +60,7 @@ public static class HalfExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this Half value)
     {
         return TimeSpan.FromHours((float)value);
@@ -71,7 +72,7 @@ public static class HalfExtensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this Half value)
     {
         return TimeSpan.FromDays((float)value);
@@ -85,7 +86,7 @@ public static class HalfExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this Half value)
     {
         return TimeSpan.FromDays((float)value * 7);

X10D/src/Time/Int16Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Time;
@@ -18,11 +19,7 @@ public static class Int16Extensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this short value)
     {
         if (value == 0)
@@ -53,11 +50,7 @@ public static class Int16Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this short value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -78,11 +71,7 @@ public static class Int16Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this short value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -94,11 +83,7 @@ public static class Int16Extensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this short value)
     {
         return TimeSpan.FromTicks(value);
@@ -112,11 +97,7 @@ public static class Int16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this short value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -130,11 +111,7 @@ public static class Int16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this short value)
     {
         return TimeSpan.FromSeconds(value);
@@ -148,11 +125,7 @@ public static class Int16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this short value)
     {
         return TimeSpan.FromMinutes(value);
@@ -166,11 +139,7 @@ public static class Int16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this short value)
     {
         return TimeSpan.FromHours(value);
@@ -182,11 +151,7 @@ public static class Int16Extensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this short value)
     {
         return TimeSpan.FromDays(value);
@@ -200,11 +165,7 @@ public static class Int16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this short value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/Int32Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Time;
@@ -18,11 +19,7 @@ public static class Int32Extensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this int value)
     {
         if (value == 0)
@@ -53,11 +50,7 @@ public static class Int32Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this int value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -78,11 +71,7 @@ public static class Int32Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this int value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -94,11 +83,7 @@ public static class Int32Extensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this int value)
     {
         return TimeSpan.FromTicks(value);
@@ -112,11 +97,7 @@ public static class Int32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this int value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -130,11 +111,7 @@ public static class Int32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this int value)
     {
         return TimeSpan.FromSeconds(value);
@@ -148,11 +125,7 @@ public static class Int32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this int value)
     {
         return TimeSpan.FromMinutes(value);
@@ -166,11 +139,7 @@ public static class Int32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this int value)
     {
         return TimeSpan.FromHours(value);
@@ -182,11 +151,7 @@ public static class Int32Extensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this int value)
     {
         return TimeSpan.FromDays(value);
@@ -200,11 +165,7 @@ public static class Int32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this int value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/Int64Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Time;
@@ -18,11 +19,7 @@ public static class Int64Extensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this long value)
     {
         if (value == 0)
@@ -53,11 +50,7 @@ public static class Int64Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this long value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -78,11 +71,7 @@ public static class Int64Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this long value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -94,11 +83,7 @@ public static class Int64Extensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this long value)
     {
         return TimeSpan.FromTicks(value);
@@ -112,11 +97,7 @@ public static class Int64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this long value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -130,11 +111,7 @@ public static class Int64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this long value)
     {
         return TimeSpan.FromSeconds(value);
@@ -148,11 +125,7 @@ public static class Int64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this long value)
     {
         return TimeSpan.FromMinutes(value);
@@ -166,11 +139,7 @@ public static class Int64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this long value)
     {
         return TimeSpan.FromHours(value);
@@ -182,11 +151,7 @@ public static class Int64Extensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this long value)
     {
         return TimeSpan.FromDays(value);
@@ -200,11 +165,7 @@ public static class Int64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this long value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/SByteExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 using X10D.Math;
 
 namespace X10D.Time;
@@ -19,11 +20,7 @@ public static class SByteExtensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this sbyte value)
     {
         if (value == 0)
@@ -54,11 +51,7 @@ public static class SByteExtensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this sbyte value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -79,11 +72,7 @@ public static class SByteExtensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this sbyte value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -95,11 +84,7 @@ public static class SByteExtensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this sbyte value)
     {
         return TimeSpan.FromTicks(value);
@@ -113,11 +98,7 @@ public static class SByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this sbyte value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -131,11 +112,7 @@ public static class SByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this sbyte value)
     {
         return TimeSpan.FromSeconds(value);
@@ -149,11 +126,7 @@ public static class SByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this sbyte value)
     {
         return TimeSpan.FromMinutes(value);
@@ -167,11 +140,7 @@ public static class SByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this sbyte value)
     {
         return TimeSpan.FromHours(value);
@@ -183,11 +152,7 @@ public static class SByteExtensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this sbyte value)
     {
         return TimeSpan.FromDays(value);
@@ -201,11 +166,7 @@ public static class SByteExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this sbyte value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/SingleExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -16,11 +17,7 @@ public static class SingleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this float value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -34,11 +31,7 @@ public static class SingleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this float value)
     {
         return TimeSpan.FromSeconds(value);
@@ -52,11 +45,7 @@ public static class SingleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this float value)
     {
         return TimeSpan.FromMinutes(value);
@@ -70,11 +59,7 @@ public static class SingleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this float value)
     {
         return TimeSpan.FromHours(value);
@@ -86,11 +71,7 @@ public static class SingleExtensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this float value)
     {
         return TimeSpan.FromDays(value);
@@ -104,11 +85,7 @@ public static class SingleExtensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this float value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/StringExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -57,11 +58,7 @@ public static class StringExtensions
     /// <returns>A new instance of <see cref="TimeSpan" />.</returns>
     /// <exception cref="ArgumentNullException"><paramref name="input" /> is <see langword="null" />.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan ToTimeSpan(this string input)
     {
 #if NET6_0_OR_GREATER

X10D/src/Time/TimeSpanExtensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -16,11 +17,7 @@ public static class TimeSpanExtensions
     ///     A <see cref="DateTime" /> that is a duration of <paramref name="value" /> in the past relative to the current time.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime Ago(this TimeSpan value)
     {
         return DateTime.Now.Subtract(value);
@@ -34,11 +31,7 @@ public static class TimeSpanExtensions
     ///     A <see cref="DateTime" /> that is a duration of <paramref name="value" /> in the future relative to the current time.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTime FromNow(this TimeSpan value)
     {
         return DateTime.Now.Add(value);

X10D/src/Time/UInt16Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -24,11 +25,7 @@ public static class UInt16Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this ushort value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -49,11 +46,7 @@ public static class UInt16Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this ushort value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -68,11 +61,7 @@ public static class UInt16Extensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this ushort value)
     {
         if (value == 0)
@@ -89,11 +78,7 @@ public static class UInt16Extensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this ushort value)
     {
         return TimeSpan.FromTicks(value);
@@ -107,11 +92,7 @@ public static class UInt16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this ushort value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -125,11 +106,7 @@ public static class UInt16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this ushort value)
     {
         return TimeSpan.FromSeconds(value);
@@ -143,11 +120,7 @@ public static class UInt16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this ushort value)
     {
         return TimeSpan.FromMinutes(value);
@@ -161,11 +134,7 @@ public static class UInt16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this ushort value)
     {
         return TimeSpan.FromHours(value);
@@ -177,11 +146,7 @@ public static class UInt16Extensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this ushort value)
     {
         return TimeSpan.FromDays(value);
@@ -195,11 +160,7 @@ public static class UInt16Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this ushort value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/UInt32Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -24,11 +25,7 @@ public static class UInt32Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this uint value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds(value);
@@ -49,11 +46,7 @@ public static class UInt32Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this uint value)
     {
         return DateTimeOffset.FromUnixTimeSeconds(value);
@@ -68,11 +61,7 @@ public static class UInt32Extensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this uint value)
     {
         if (value == 0)
@@ -89,11 +78,7 @@ public static class UInt32Extensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this uint value)
     {
         return TimeSpan.FromTicks(value);
@@ -107,11 +92,7 @@ public static class UInt32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this uint value)
     {
         return TimeSpan.FromMilliseconds(value);
@@ -125,11 +106,7 @@ public static class UInt32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this uint value)
     {
         return TimeSpan.FromSeconds(value);
@@ -143,11 +120,7 @@ public static class UInt32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this uint value)
     {
         return TimeSpan.FromMinutes(value);
@@ -161,11 +134,7 @@ public static class UInt32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this uint value)
     {
         return TimeSpan.FromHours(value);
@@ -177,11 +146,7 @@ public static class UInt32Extensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this uint value)
     {
         return TimeSpan.FromDays(value);
@@ -195,11 +160,7 @@ public static class UInt32Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this uint value)
     {
         return TimeSpan.FromDays(value * 7);

X10D/src/Time/UInt64Extensions.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using X10D.CompilerServices;
 
 namespace X10D.Time;
 
@@ -24,11 +25,7 @@ public static class UInt64Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799,999.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeMilliseconds(this ulong value)
     {
         return DateTimeOffset.FromUnixTimeMilliseconds((long)value);
@@ -49,11 +46,7 @@ public static class UInt64Extensions
     ///     <para><paramref name="value" /> is greater than 253,402,300,799.</para>
     /// </exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static DateTimeOffset FromUnixTimeSeconds(this ulong value)
     {
         return DateTimeOffset.FromUnixTimeSeconds((long)value);
@@ -68,11 +61,7 @@ public static class UInt64Extensions
     /// </returns>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="value" /> is 0.</exception>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static bool IsLeapYear(this ulong value)
     {
         if (value == 0)
@@ -89,11 +78,7 @@ public static class UInt64Extensions
     /// <param name="value">The duration, in ticks.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.Ticks" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Ticks(this ulong value)
     {
         return TimeSpan.FromTicks((long)value);
@@ -107,11 +92,7 @@ public static class UInt64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMilliseconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Milliseconds(this ulong value)
     {
         return TimeSpan.FromMilliseconds((long)value);
@@ -125,11 +106,7 @@ public static class UInt64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalSeconds" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Seconds(this ulong value)
     {
         return TimeSpan.FromSeconds((long)value);
@@ -143,11 +120,7 @@ public static class UInt64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalMinutes" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Minutes(this ulong value)
     {
         return TimeSpan.FromMinutes((long)value);
@@ -161,11 +134,7 @@ public static class UInt64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalHours" /> will equal <paramref name="value" />.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Hours(this ulong value)
     {
         return TimeSpan.FromHours((long)value);
@@ -177,11 +146,7 @@ public static class UInt64Extensions
     /// <param name="value">The duration, in days.</param>
     /// <returns>A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" />.</returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Days(this ulong value)
     {
         return TimeSpan.FromDays((long)value);
@@ -195,11 +160,7 @@ public static class UInt64Extensions
     ///     A <see cref="TimeSpan" /> whose <see cref="TimeSpan.TotalDays" /> will equal <paramref name="value" /> × 7.
     /// </returns>
     [Pure]
-#if NETSTANDARD2_1
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#else
-    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-#endif
+    [MethodImpl(CompilerResources.MethodImplOptions)]
     public static TimeSpan Weeks(this ulong value)
     {
         return TimeSpan.FromDays((long)value * 7);