public void FactorCountZero()
{
var expected = 0;
var actual = Factorization.FactorCount(0);
Assert.Equal(expected, actual);
}
public void GCDLong()
{
var expected = 4;
var actual = Factorization.GCD(412L, 612L);
Assert.Equal(expected, actual);
}
public void LCMInt()
{
var expected = 336;
var actual = Factorization.LCM(42, 16);
Assert.Equal(expected, actual);
}
public static void FirstStep(DLPInput input, BigInteger[] factorBase, ref List <List <BigInteger> > coefficients, ref List <BigInteger> constantTerms)
{
var rand = new BigIntegerRandom();
for (int i = 1; i < input.order; i++)
{
//var k = rand.Next(0, input.order);
//while (k == 0)
//{
// k = rand.Next(0, input.order);
//}
var k = input.order - i;
var temp = BigInteger.ModPow(input.g, k, input.p);
var factorBaseFactorizationExponents = Factorization.GetFactorBaseFactorizationExponents(temp, factorBase);
if (factorBaseFactorizationExponents != null)
{
coefficients.Add(factorBaseFactorizationExponents.ToList());
constantTerms.Add(k);
//bool isLinearIndependent = GaussianElimination.IsLinearIndependent(coefficients, input.order);
//if (!isLinearIndependent)
// coefficients.RemoveAt(coefficients.Count - 1);
//else
// constantTerms.Add(k);
}
//if (coefficients.Count == factorBase.Length)
if (coefficients.Count == LinearEquatationsCount)
{
return;
}
}
}
public void PrimeFactorsPrime()
{
var expected = 1;
var actual = Factorization.PrimeFactors(112272535095293).Count();
Assert.Equal(expected, actual);
}
public void PrimeFactorsBigInteger()
{
var expected = new BigInteger[] { 2, 3, 13, 163, 514884037 };
var actual = Factorization.PrimeFactors(new BigInteger(6546235646418));
Assert.True(expected.SequenceEqual(actual));
}
public void PrimeFactorsLong()
{
var expected = new long[] { 2, 2, 5, 103 };
var actual = Factorization.PrimeFactors(2060L);
Assert.True(expected.SequenceEqual(actual));
}
public void FactorCount()
{
var expected = 12;
var actual = Factorization.FactorCount(90);
Assert.Equal(expected, actual);
}
public void FactorsLong()
{
var expected = new long[] { 1, 2, 4, 103, 206, 412 };
var actual = Factorization.Factors(412L);
Assert.True(expected.OrderBy(sequence => sequence).SequenceEqual(actual.OrderBy(sequence => sequence)));
}
public void PrimeFactorsNonPrime()
{
var expected = 5;
var actual = Factorization.PrimeFactors(6546235646418).Count();
Assert.Equal(expected, actual);
}
public void FactorsBigIntegerPrime()
{
var expected = 2;
var actual = Factorization.Factors(new BigInteger(112272535095293)).Count();
Assert.Equal(expected, actual);
}
public void FactorsBigInteger()
{
var expected = new BigInteger[] { 1, 2, 4, 103, 206, 412 };
var actual = Factorization.Factors(new BigInteger(412));
Assert.True(expected.OrderBy(sequence => sequence).SequenceEqual(actual.OrderBy(sequence => sequence)));
}
public void FactorsBigIntegerNonPrime()
{
var expected = 32;
var actual = Factorization.Factors(new BigInteger(6546235646418)).Count();
Assert.Equal(expected, actual);
}
public void Simple6()
{
List<long> f = new Factorization(6).ToList();
Assert.AreEqual(2, f.Count);
Assert.AreEqual(2, f[0]);
Assert.AreEqual(3, f[1]);
}
public void GCDInt()
{
var expected = 4;
var actual = Factorization.GCD(412, 612);
Assert.Equal(expected, actual);
}
static void Main(string[] args)
{
MyTimer timer = new MyTimer();
//long NumberToCheck = 54996816813;
long NumberToCheck = 5791;
timer.Start();
Console.WriteLine("Factorizing:\t{0:N0}", NumberToCheck);
List <long> NumberFactors = Factorization.Factorize(NumberToCheck);
Console.WriteLine("Factorization is:");
int counter = NumberFactors.Count;
foreach (int factor in NumberFactors)
{
counter--;
Console.Write(factor);
if (counter != 0)
{
Console.Write("x");
}
}
Console.WriteLine("");
Console.WriteLine("Calculation took: {0}", timer.Elapsed);
Console.Read();
}
public void PrimeFactorsLongZero()
{
var expected = new long[] { };
var actual = Factorization.PrimeFactors(0L);
Assert.True(expected.SequenceEqual(actual));
}
public void LCMLong()
{
var expected = 336;
var actual = Factorization.LCM(42L, 16L);
Assert.Equal(expected, actual);
}
public void PrimeFactorsIntZero()
{
var expected = new int[] { };
var actual = Factorization.PrimeFactors(0);
Assert.True(expected.SequenceEqual(actual));
}
public void PrimeFactorsBigIntegerZero()
{
var expected = new BigInteger[] { };
var actual = Factorization.PrimeFactors(BigInteger.Zero);
Assert.True(expected.SequenceEqual(actual));
}
public void LCMBigInteger()
{
var expected = new BigInteger(336);
var actual = Factorization.LCM(new BigInteger(42), 16L);
Assert.Equal(expected, actual);
}
/// <summary>
/// This routine gets the algorithm used for the refactorization in cusolverRfRefactor()
/// and the triangular solve in cusolverRfSolve(). It may be called once prior to
/// cusolverRfAnalyze() routine.
/// </summary>
/// <param name="factAlg">the enumerated algorithm type.</param>
/// <param name="solveAlg">the enumerated algorithm type.</param>
public void GetAlgs(ref Factorization factAlg, ref TriangularSolve solveAlg)
{
res = CudaSolveNativeMethods.Refactorization.cusolverRfGetAlgs(_handle, ref factAlg, ref solveAlg);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverRfGetAlgs", res));
if (res != cusolverStatus.Success)
{
throw new CudaSolveException(res);
}
}
public void GetFactors_FactorizationOf825_ReturnCollection()
{
var expected = new List <int> {
3, 5, 5, 11
};
var result = Factorization.GetFactorsOf(825);
result.Should().BeEquivalentTo(expected);
}
public void GetFactors_FactorizationOf1386_ReturnCollection()
{
var expected = new List <int> {
2, 3, 3, 7, 11
};
var result = Factorization.GetFactorsOf(1386);
result.Should().BeEquivalentTo(expected);
}
public void TestGetPrimeFactors(int n, int[] expectedPrimeFactors)
{
var factorization = new Factorization();
var primeFactors = factorization.GetPrimeFactors(n).OrderBy(n => n).ToArray();
Assert.AreEqual(expectedPrimeFactors.Length, primeFactors.Length);
for (int i = 0; i < primeFactors.Length; i++)
{
Assert.AreEqual(expectedPrimeFactors[i], primeFactors[i]);
}
}
public static List <string> CheckTests(string way, List <string> rules)
{
var parsedRules = Parser.ParseInput(File.OpenRead(way));
var factorizedRules = Factorization.RemoveFactorization(parsedRules);
var removedRecursionRules = LeftRecursionRemover.RemoveLeftRecursion(factorizedRules);
var leads = Leads.FindLeads(removedRecursionRules).ToList();
rules.AddRange(removedRecursionRules.Rules.Select((t, i) => t + " / " + ConvertLead(leads[i])));
return(rules);
}
public void TrialDivisionTest()
{
const long value = 7399;
var result = Factorization.TrialDivision(value);
var expectedResult = new long[] { 7, 7, 151 };
var isEqual = result.SequenceEqual(expectedResult);
Assert.IsTrue(isEqual, "Trial Division has an incorrect result");
}
public void FermatFactorTest()
{
const long value = 10873;
var result = Factorization.FermatFactor(value);
const long expectedX = 131;
const long expectedY = 83;
Assert.IsTrue(result.X == expectedX && result.Y == expectedY, "Fermat Factor has an incorrect result");
}
public void MultipleFactors1()
{
List<long> f = new Factorization(2*2*3*5*7*11).ToList();
Assert.AreEqual(6, f.Count);
Assert.AreEqual(2, f[0]);
Assert.AreEqual(2, f[1]);
Assert.AreEqual(3, f[2]);
Assert.AreEqual(5, f[3]);
Assert.AreEqual(7, f[4]);
Assert.AreEqual(11, f[5]);
}
/// <summary>
/// Returns the product of the distinct prime factors of n
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static long Rad(long n)
{
if (n == 1)
{
return(1);
}
return(Factorization
.PrimeFactors(n)
.Distinct()
.Aggregate((prod, next) => prod * next));
}
public void TestGetFactors(int n)
{
var factorization = new Factorization();
var factors = factorization.GetFactors(n).OrderBy(n => n.SmallerFactor).ToArray();
var expectedFactors = expectedFactorPairs[n].OrderBy(n => n.SmallerFactor).ToArray();
Assert.AreEqual(expectedFactors.Length, factors.Length);
for (int i = 0; i < factors.Length; i++)
{
Assert.AreEqual(expectedFactors[i].SmallerFactor, factors[i].SmallerFactor);
Assert.AreEqual(expectedFactors[i].LargerFactor, factors[i].LargerFactor);
}
}
static void Main(string[] args)
{
// Rho Pollard
var primeA = "99194853094755497".ToOmgNum();
var primeB = "2971215073".ToOmgNum();
var primesProd = OmgOp.Multiply(primeA, primeB);
var polard = new PolardFactorization();
var factor = polard.FindFactor(primesProd);
Console.WriteLine($"factor: {factor}");
// Rho Discrete Log
var rhoLogFinder = new RhoLog();
(OmgNum a, OmgNum b, OmgNum p)log = (5.ToOmgNum(), 3.ToOmgNum(), 2017.ToOmgNum());
var discreteLog = rhoLogFinder.FindLog(log.a, log.b, log.p);
Console.WriteLine($"{discreteLog} : {OmgOp.Pow(log.a, discreteLog, log.p)}");
// Factorization
var factorizer = new Factorization();
var factorization = factorizer.Factorize("63782453".ToOmgNum());
Console.WriteLine($"factorization: {String.Join(' ', factorization.Select(x => ($"{x.Key}^{x.Value}")))}");
// EulerF
var euler = factorizer.EulerFunction("63782453".ToOmgNum());
Console.WriteLine($"euler: {euler}");
// MobiusF
var mobius1 = factorizer.Mobius("63782453".ToOmgNum());
var mobius2 = factorizer.Mobius("4".ToOmgNum());
Console.WriteLine($"mobius1: {mobius1}");
Console.WriteLine($"mobius2: {mobius2}");
}
public static extern cusolverStatus cusolverRfGetAlgs(cusolverRfHandle handle, ref Factorization factAlg, ref TriangularSolve solveAlg);
public void Simple5()
{
List<long> f = new Factorization(5).ToList();
Assert.AreEqual(1, f.Count);
Assert.AreEqual(5, f[0]);
}
/// <summary>
/// This routine gets the algorithm used for the refactorization in cusolverRfRefactor()
/// and the triangular solve in cusolverRfSolve(). It may be called once prior to
/// cusolverRfAnalyze() routine.
/// </summary>
/// <param name="factAlg">the enumerated algorithm type.</param>
/// <param name="solveAlg">the enumerated algorithm type.</param>
public void GetAlgs(ref Factorization factAlg, ref TriangularSolve solveAlg)
{
res = CudaSolveNativeMethods.Refactorization.cusolverRfGetAlgs(_handle, ref factAlg, ref solveAlg);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cusolverRfGetAlgs", res));
if (res != cusolverStatus.Success) throw new CudaSolveException(res);
}
