public FactoredRational(Rational rational, IPrimeFactorizer factorizer)
{
if (rational.numerator == 0 || rational.denominator == 0)
{
this.numerator = rational.numerator;
this.denominator = rational.denominator;
this.primeFactors = PoweredPrime.None;
}
else
{
//
// Take the absolute value of the rational
//
PoweredPrime[] denominatorFactors = factorizer.PrimeFactorize(rational.denominator);
if (denominatorFactors == null)
{
throw factorizer.UnableToFactorize(rational.denominator);
}
UInt32 numeratorAbsoluteValue = (UInt32)((rational.numerator >= 0) ? rational.numerator : -rational.numerator);
this.primeFactors = factorizer.Divide(numeratorAbsoluteValue, denominatorFactors);
if (this.primeFactors == null)
{
throw factorizer.UnableToDivide(numeratorAbsoluteValue, denominatorFactors);
}
// Get new numerator and denominator
this.numerator = 1;
this.denominator = 1;
for (int i = 0; i < this.primeFactors.Length; i++)
{
PoweredPrime factor = this.primeFactors[i];
if (factor.power > 0)
{
numerator *= (Int32)factor.value;
// I don't need to check overflow here because these factors came from an Int32
}
else
{
denominator *= factor.value;
// I don't need to check overflow here because these factors came from a UInt32
}
}
if (rational.numerator < 0)
{
numerator = -numerator;
}
}
}
void TestFactorizer(IPrimeFactorizer factorizer)
{
Assert.AreEqual(PoweredPrime.None, factorizer.PrimeFactorize(0));
Assert.AreEqual(PoweredPrime.None, factorizer.PrimeFactorize(1));
TestFactorize(factorizer, 2, new PoweredPrime(2, 1));
TestFactorize(factorizer, 3, new PoweredPrime(3, 1));
TestFactorize(factorizer, 4, new PoweredPrime(2, 2));
TestFactorize(factorizer, 5, new PoweredPrime(5, 1));
TestFactorize(factorizer, 6, new PoweredPrime(2, 1), new PoweredPrime(3, 1));
TestFactorize(factorizer, 7, new PoweredPrime(7, 1));
TestFactorize(factorizer, 8, new PoweredPrime(2, 3));
TestFactorize(factorizer, 9, new PoweredPrime(3, 2));
TestFactorize(factorizer, 10, new PoweredPrime(2, 1), new PoweredPrime(5, 1));
TestFactorize(factorizer, 11, new PoweredPrime(11, 1));
TestFactorize(factorizer, 12, new PoweredPrime(2, 2), new PoweredPrime(3, 1));
TestFactorize(factorizer, 13, new PoweredPrime(13, 1));
TestFactorize(factorizer, 14, new PoweredPrime(2, 1), new PoweredPrime(7, 1));
TestFactorize(factorizer, 15, new PoweredPrime(3, 1), new PoweredPrime(5, 1));
TestFactorize(factorizer, 16, new PoweredPrime(2, 4));
TestFactorize(factorizer, 17, new PoweredPrime(17, 1));
TestFactorize(factorizer, 18, new PoweredPrime(2, 1), new PoweredPrime(3, 2));
TestFactorize(factorizer, 19, new PoweredPrime(19, 1));
}
public static FactoredUInt32 Create(UInt32 value, IPrimeFactorizer factorizer)
{
if (value <= 3)
{
return(FirstFour[value]);
}
PoweredPrime[] factors = factorizer.PrimeFactorize(value);
if (factors == null)
{
throw factorizer.UnableToFactorize(value);
}
return(new FactoredUInt32(value, factors));
}
void TestFactorize(IPrimeFactorizer factorizer, UInt32 value, params PoweredPrime[] expectedPrimeFactors)
{
PoweredPrime[] calculatedPrimeFactors = factorizer.PrimeFactorize(value);
builder.Length = 0;
calculatedPrimeFactors.SerializeArray(builder);
Console.WriteLine("Value '{0}' PrimeFactors: {1}", value, builder.ToString());
String sosDiff = expectedPrimeFactors.Diff(calculatedPrimeFactors);
if (sosDiff != null)
{
Assert.Fail("Diff {0}", sosDiff);
}
}
public static FactoredInt32 Create(Int32 value, IPrimeFactorizer factorizer)
{
if (value >= 0 && value <= 3)
{
return(FirstFour[value]);
}
UInt32 absoluteValue = (UInt32)((value >= 0) ? value : -value);
PoweredPrime[] factors = factorizer.PrimeFactorize(absoluteValue);
if (factors == null)
{
throw factorizer.UnableToFactorize(absoluteValue);
}
return(new FactoredInt32(value, factors));
}
public PoweredPrime[] PrimeFactorize(UInt32 value)
{
PoweredPrime[] factors;
if (cachedUInt32Factorizations.TryGetValue(value, out factors))
{
return(factors);
}
factors = underlyingFactorizer.PrimeFactorize(value);
if (factors == null)
{
return(null);
}
cachedUInt32Factorizations.Add(value, factors);
return(factors);
}
void GetMaxPrime(IPrimeFactorizer factorizer, UInt32 printEvery)
{
UInt32 i = 0;
while (true)
{
try
{
PoweredPrime[] primeFactors = factorizer.PrimeFactorize(i);
if (i % printEvery == 0)
{
builder.Length = 0;
primeFactors.SerializeArray(builder);
Console.WriteLine("Value '{0}' PrimeFactors: {1}", i, builder.ToString());
}
}
catch (Exception e)
{
Console.WriteLine("At {0}, got exception {1}", i, e);
throw;
}
i++;
}
}
