void CorrectPrimeBigSerieTest()
{
List <uint> expectedPrimeSerie = new List <uint> {
2, 2, 2, 2, 3, 5, 5, 7
};
List <uint> generatedPrimeSerie = PrimeFactorization.ObtainNumersPrime(8400);
Assert.Equal(expectedPrimeSerie, generatedPrimeSerie);
}
private long divisorCount(long triangle)
{
PrimeFactorization p = Prime.factorize(triangle);
long count = 1;
foreach (var e in p.Exponents)
{
count *= (e + 1);
}
return(count);
}
public void Factorize_More_NonPrime_Nums_Test()
{
PrimeFactorization pm = new PrimeFactorization();
CollectionAssert.AreEqual(new int[] { 3, 7 }, pm.Factorize(21));
CollectionAssert.AreEqual(new int[] { 3, 3, 11 }, pm.Factorize(99));
CollectionAssert.AreEqual(new int[] { 2, 2, 2, 2, 2, 2, 2, 2 }, pm.Factorize(256));
CollectionAssert.AreEqual(new int[] { 2, 2, 7, 73 }, pm.Factorize(2044));
CollectionAssert.AreEqual(new int[] { 7, 11, 101 }, pm.Factorize(7777));
CollectionAssert.AreEqual(new int[] { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, pm.Factorize(8192));
}
public void Factorize_More_Prime_Nums_Test()
{
PrimeFactorization pm = new PrimeFactorization();
CollectionAssert.AreEqual(new int[] { 11 }, pm.Factorize(11));
CollectionAssert.AreEqual(new int[] { 13 }, pm.Factorize(13));
CollectionAssert.AreEqual(new int[] { 17 }, pm.Factorize(17));
CollectionAssert.AreEqual(new int[] { 193 }, pm.Factorize(193));
CollectionAssert.AreEqual(new int[] { 5209 }, pm.Factorize(5209));
CollectionAssert.AreEqual(new int[] { 7919 }, pm.Factorize(7919));
}
public void TestIsEven()
{
var odd = PrimeFactorization.IsEven(5);
var even = PrimeFactorization.IsEven(14);
var zero = PrimeFactorization.IsEven(0);
var negative = PrimeFactorization.IsEven(-2);
Assert.AreEqual(false, odd);
Assert.AreEqual(true, even);
Assert.AreEqual(true, zero);
Assert.AreEqual(false, negative);
}
public void FindCorrectPrimeNumbersBetweenZeroAndTwenty()
{
var primes = PrimeFactorization.FindPrimeNumbers(0, 20);
Assert.AreEqual(8, primes.Count);
Assert.AreEqual(2, primes[0]);
Assert.AreEqual(3, primes[1]);
Assert.AreEqual(5, primes[2]);
Assert.AreEqual(7, primes[3]);
Assert.AreEqual(11, primes[4]);
Assert.AreEqual(13, primes[5]);
Assert.AreEqual(17, primes[6]);
}
public void ExponantsAndPrimes()
{
//arrange
PrimeFactorization pm = new PrimeFactorization();
//act
var num342 = pm.ExpessFactors(342);
var num837 = pm.ExpessFactors(847);
var num57400 = pm.ExpessFactors(57400);
//assert
num342.Should().Be("2 X 3^2 X 19");
num837.Should().Be("7 X 11^2");
num57400.Should().Be("2^3 X 5^2 X 7 X 41");
}
public void OnlyExponants()
{
//arrange
PrimeFactorization pm = new PrimeFactorization();
//act
var num36 = pm.ExpessFactors(36);
var num900 = pm.ExpessFactors(900);
var num40500 = pm.ExpessFactors(40500);
var num8000 = pm.ExpessFactors(8000);
//assert
num36.Should().Be("2^2 X 3^2");
num900.Should().Be("2^2 X 3^2 X 5^2");
num40500.Should().Be("2^2 X 3^4 X 5^3");
num8000.Should().Be("2^6 X 5^3");
}
public void SinglePrime()
{
//arrange
PrimeFactorization pm = new PrimeFactorization();
//act
var num1 = pm.ExpessFactors(2);
var num13 = pm.ExpessFactors(13);
var num347 = pm.ExpessFactors(347);
var num63443 = pm.ExpessFactors(63443);
//assert
num1.Should().Be("2");
num13.Should().Be("13");
num347.Should().Be("347");
num63443.Should().Be("63443");
}
public static IEnumerable <long> GeneratePrimeNumbers(int amountToGenerate)
{
var primeNumbers = new List <long>();
long minValue = 0;
long patchSize = 100;
var maxValue = patchSize;
while (primeNumbers.Count <= amountToGenerate)
{
var foundPrimes = PrimeFactorization.FindPrimeNumbers(minValue, maxValue);
primeNumbers.AddRange(foundPrimes);
var lastIndex = primeNumbers.Count - 1;
minValue = primeNumbers[lastIndex] + 1;
maxValue = primeNumbers[lastIndex] + patchSize;
}
return(primeNumbers.Take(amountToGenerate));
}
public void NoExponants()
{
//arrange
PrimeFactorization pm = new PrimeFactorization();
//act
var num14 = pm.ExpessFactors(14);
var num30 = pm.ExpessFactors(30);
var num115 = pm.ExpessFactors(115);
var num7854 = pm.ExpessFactors(7854);
var num34114 = pm.ExpessFactors(34114);
//assert
num14.Should().Be("2 X 7");
num30.Should().Be("2 X 3 X 5");
num115.Should().Be("5 X 23");
num7854.Should().Be("2 X 3 X 7 X 11 X 17");
num34114.Should().Be("2 X 37 X 461");
}
public static List <long> GetCollatzSequence(long startingValue)
{
if (startingValue <= 0)
{
throw new ArgumentException("Value must be bigger than 0.");
}
var currentValue = startingValue;
var result = new List <long> {
startingValue
};
while (currentValue != 1)
{
currentValue = PrimeFactorization.IsEven(currentValue) ? ApplyRuleForEvenNumber(currentValue) : ApplyRuleForOddNumber(currentValue);
result.Add(currentValue);
}
return(result);
}
private void writeTxtBxFactors(Int64 intToFactor)
{
PrimeFactorization pF = new PrimeFactorization(intToFactor); List <Int64> li = pF.Factor();
string f = "";
foreach (Int64 i in li)
{
if (f == "")
{
f = i.ToString();
}
else
{
f = f + "*" + i;
}
}
txtBxFactors.Text = f;
}
public void TestCleanup()
{
PrimeFactorization = null;
}
public void TestZeroIsNotAPrimeNumber()
{
var result = PrimeFactorization.IsPrimeNumber(0);
Assert.AreEqual(false, result);
}
public void TestInitialize()
{
PrimeFactorization = new PrimeFactorization();
}
private void isNotPrime(int num)
{
Assert.IsFalse(PrimeFactorization.IsPrime(num));
}
private void arePrimeFactorsCorrect(int num, List <int> primeFactors)
{
Assert.IsTrue(primeFactors.SequenceEqual(PrimeFactorization.GetPrimeFactors(num)));
}
public void MultipleOfPrimeNumberIsNotPrimeNumber()
{
var result = PrimeFactorization.IsPrimeNumber(7 * 3);
Assert.AreEqual(false, result);
}
public void NegativeNumberIsNotPrimeNumber()
{
var result = PrimeFactorization.IsPrimeNumber(-5);
Assert.AreEqual(false, result);
}
public void TestTwoIsAPrimeNumber()
{
var result = PrimeFactorization.IsPrimeNumber(2);
Assert.AreEqual(true, result);
}
public void EvenNumberGreaterThanTwoIsNotPrimeNumber()
{
var result = PrimeFactorization.IsPrimeNumber(6);
Assert.AreEqual(false, result);
}
public void Factorize_Negative1_Rtrns_Empty_Array_Test()
{
PrimeFactorization pm = new PrimeFactorization();
CollectionAssert.AreEqual(new int[] { }, pm.Factorize(-1));
}
private void isPrime(int num)
{
Assert.IsTrue(PrimeFactorization.IsPrime(num));
}
public void PrimeFactorizationValueTest()
{
List <int> primeFactors = PrimeFactorization.Factorize(13195);
Assert.AreEqual(29, primeFactors[^ 1]);
public void Factorize6_Rtrns_2_3_Test()
{
PrimeFactorization pm = new PrimeFactorization();
CollectionAssert.AreEqual(new int[] { 2, 3 }, pm.Factorize(6));
}
public void Factorize7_Rtrns_7_Test()
{
PrimeFactorization pm = new PrimeFactorization();
CollectionAssert.AreEqual(new int[] { 7 }, pm.Factorize(7));
}
public void Factorize8_Rtrns_2_2_2_Test()
{
PrimeFactorization pm = new PrimeFactorization();
CollectionAssert.AreEqual(new int[] { 2, 2, 2 }, pm.Factorize(8));
}
public void PrimeFactorizationSizeTest()
{
List <int> primeFactors = PrimeFactorization.Factorize(13195);
Assert.AreEqual(4, primeFactors.Count);
}
