public void CompareToTest()
{
// Higher powers of the same prime are greater
Assert.That((new PrimeFactors(4)).CompareTo(new PrimeFactors(2)) > 0);
// Higher primes are greater
Assert.That((new PrimeFactors(3)).CompareTo(new PrimeFactors(2)) > 0);
// Equality semantics
for (var i = 1; i < 1000; i++)
{
var iFactors = new PrimeFactors(i);
for (var j = 1; j < 1000; j++)
{
var jFactors = new PrimeFactors(j);
if (i == j)
{
Assert.That(iFactors.CompareTo(jFactors), Is.EqualTo(0), "Prime Factors of equal numbers must compare equal.");
}
else
{
Assert.That(iFactors.CompareTo(jFactors), Is.Not.EqualTo(0), "Prime Factors of distinct numbers must compare not-equal.");
}
}
}
}
public void InverseFactorTest()
{
for (var i = 1; i < 1000; i++)
{
var powers = PrimeFactors.Factor(i);
Assert.That(PrimeFactors.Value(powers), Is.EqualTo(i));
}
}
public void FactorTest()
{
var r32 = new[] { 5 };
var r210 = new[] { 1, 1, 1, 1 };
Assert.That(PrimeFactors.Factor(32), Is.EqualTo(r32));
Assert.That(PrimeFactors.Factor(210), Is.EqualTo(r210));
}
/// <summary>
/// Generate an iterator over the proper divisors of the number passed in,
/// other than the number itself.
/// Iteration will proceed as for <see cref="Divisors(int[])"/>.
/// </summary>
/// <param name="value">Value whose divisors are desired</param>
/// <returns>An enumerator over all proper divisors of the number.</returns>
public static IEnumerable <int> ProperDivisors(int value)
{
var factors = PrimeFactors.Factor(value);
foreach (var i in Divisors(factors))
{
if (i < value)
{
yield return(i);
}
}
}
/// <summary>
/// Get the perfection of a number. A number whose proper divisors
/// add up to the number is called "perfect". If the sum is less then the
/// number it is called "deficient". Otherwise it is called "abundant".
/// </summary>
/// <param name="factors">Prime factor powers of the number</param>
/// <returns>-1 if deficient, 0 if perfect, 1 if abundant</returns>
public static int Perfection(int[] factors)
{
var sum = 0;
var value = PrimeFactors.Value(factors);
foreach (var i in ProperDivisors(factors))
{
sum += i;
if (sum > value)
{
return(1);
}
}
return((sum < value) ? -1 : 0);
}
/// <summary>
/// Count the number of possible divisors of a number, including 1 and the number itself.
/// </summary>
/// <param name="value">The number to test.</param>
/// <returns>the number of possible divisors of the original number.</returns>
public static int CountDivisors(int value)
{
return(CountDivisors(PrimeFactors.Factor(value)));
}
/// <summary>
/// Get the perfection of a number. A number whose proper divisors
/// add up to the number is called "perfect". If the sum is less then the
/// number it is called "deficient". Otherwise it is called "abundant".
/// </summary>
/// <param name="value">The number</param>
/// <returns>-1 if deficient, 0 if perfect, 1 if abundant</returns>
public static int Perfection(int value)
{
return(Perfection(PrimeFactors.Factor(value)));
}
/// <summary>
/// Generate an iterator over the divisors of the number passed in.
/// Iteration will proceed as for <see cref="Divisors(int[])"/>.
/// </summary>
/// <param name="value">Value whose divisors are desired</param>
/// <returns>An enumerator over all divisors of the number.</returns>
public static IEnumerable <int> Divisors(int value)
{
return(Divisors(PrimeFactors.Factor(value)));
}
public void InverseFactorValue(int value)
{
var powers = PrimeFactors.Factor(value);
Assert.That(PrimeFactors.Value(powers), Is.EqualTo(value));
}
