oliverbooth/X10D
oliverbooth/X10D
1
0
Fork 0
mirror of https://github.com/oliverbooth/X10D synced 2024-11-21 16:48:47 +00:00
Code Issues

refactor!: replace T.MultiplicativePersistence with generic math

Browse Source
This commit is contained in:
Oliver Booth 2024-11-14 16:48:22 +00:00
parent 7af3c96405
commit 027f6f23e1
Signed by: oliverbooth
GPG Key ID: 2A862C3F46178E8E
11 changed files with 51 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- X10D: Removed `IEnumerable<T>.GreatestCommonFactor` for all integer types in favour of generic math.
- X10D: Removed `IEnumerable<T>.LowestCommonMultiple` for all integer types in favour of generic math.
- X10D: Removed `T.MultiplicativePersistence` for all integer types in favour of generic math.
- X10D: Removed `IEnumerable<T>.Product` for all integer types in favour of generic math.
- X10D: Removed `IEnumerable<T>.RangeTo` for all integer types in favour of generic math.
- X10D: Removed `T.Saturate` for all floating-point types in favour of generic math.

46
X10D/src/Math/BigIntegerExtensions.cs
View File

@ -90,50 +90,4 @@ public static class BigIntegerExtensions
return true;
}
/// <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.MaxOptimization)]
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;
}
}

50
X10D/src/Math/BinaryIntegerExtensions.cs
View File

@ -77,4 +77,54 @@ public static class BinaryIntegerExtensions
return result;
}
/// <summary>
/// Returns the multiplicative persistence of the current integer.
/// </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.MaxOptimization)]
public static int MultiplicativePersistence<TInteger>(this TInteger value)
where TInteger : IBinaryInteger<TInteger>
{
var nine = TInteger.CreateChecked(9);
var ten = TInteger.CreateChecked(10);
var persistence = 0;
TInteger product = TInteger.Abs(value);
while (product > nine)
{
if (value % ten == TInteger.Zero)
{
return persistence + 1;
}
while (value > nine)
{
value /= ten;
if (value % ten == TInteger.Zero)
{
return persistence + 1;
}
}
TInteger newProduct = TInteger.One;
TInteger currentProduct = product;
while (currentProduct > TInteger.Zero)
{
newProduct *= currentProduct % ten;
currentProduct /= ten;
}
product = newProduct;
persistence++;
}
return persistence;
}
}

17
X10D/src/Math/ByteExtensions.cs
View File

@ -1,6 +1,4 @@
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices;
using X10D.CompilerServices;
namespace X10D.Math;
@ -21,19 +19,4 @@ public static class ByteExtensions
{
return ((long)value).IsPrime();
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this byte value)
{
return ((long)value).MultiplicativePersistence();
}
}

15
X10D/src/Math/Int16Extensions.cs
View File

@ -22,19 +22,4 @@ public static class Int16Extensions
{
return ((long)value).IsPrime();
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this short value)
{
return ((long)value).MultiplicativePersistence();
}
}

15
X10D/src/Math/Int32Extensions.cs
View File

@ -22,19 +22,4 @@ public static class Int32Extensions
{
return ((long)value).IsPrime();
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this int value)
{
return ((long)value).MultiplicativePersistence();
}
}

46
X10D/src/Math/Int64Extensions.cs
View File

@ -41,50 +41,4 @@ public static class Int64Extensions
return true;
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this long value)
{
var persistence = 0;
long product = System.Math.Abs(value);
while (product > 9)
{
if (value % 10 == 0)
{
return persistence + 1;
}
while (value > 9)
{
value /= 10;
if (value % 10 == 0)
{
return persistence + 1;
}
}
long newProduct = 1;
long currentProduct = product;
while (currentProduct > 0)
{
newProduct *= currentProduct % 10;
currentProduct /= 10;
}
product = newProduct;
persistence++;
}
return persistence;
}
}

15
X10D/src/Math/SByteExtensions.cs
View File

@ -24,21 +24,6 @@ public static class SByteExtensions
return ((long)value).IsPrime();
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this sbyte value)
{
return ((long)value).MultiplicativePersistence();
}
/// <summary>
/// Returns an integer that indicates the sign of this 8-bit signed integer.
/// </summary>

15
X10D/src/Math/UInt16Extensions.cs
View File

@ -23,19 +23,4 @@ public static class UInt16Extensions
{
return ((ulong)value).IsPrime();
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this ushort value)
{
return ((ulong)value).MultiplicativePersistence();
}
}

15
X10D/src/Math/UInt32Extensions.cs
View File

@ -23,19 +23,4 @@ public static class UInt32Extensions
{
return ((ulong)value).IsPrime();
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this uint value)
{
return ((ulong)value).MultiplicativePersistence();
}
}

46
X10D/src/Math/UInt64Extensions.cs
View File

@ -42,50 +42,4 @@ public static class UInt64Extensions
return true;
}
/// <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.MaxOptimization)]
public static int MultiplicativePersistence(this ulong value)
{
var persistence = 0;
ulong product = value;
while (product > 9)
{
if (value % 10 == 0)
{
return persistence + 1;
}
while (value > 9)
{
value /= 10;
if (value % 10 == 0)
{
return persistence + 1;
}
}
ulong newProduct = 1;
ulong currentProduct = product;
while (currentProduct > 0)
{
newProduct *= currentProduct % 10;
currentProduct /= 10;
}
product = newProduct;
persistence++;
}
return persistence;
}
}