/// <summary> /// Solve the problem /// </summary> /// <returns>The sum result</returns> private long Solve() { int A = 0, B = 0, maxCount = 0, n = 0, num; List <long> primes; PrimeGenerator pG; Stopwatch sw = new Stopwatch(); sw.Start(); pG = new PrimeGenerator(1000); primes = pG.Primes; for (int a = -1000; a <= 1000; a++) { for (int b = -1000; b <= 1000; b++) { n = 0; num = n * n + a * n + b; while (primes.Contains(Math.Abs(num))) { n++; if (n > maxCount) { maxCount = n; A = a; B = b; Console.Clear(); Console.WriteLine("A:{0} B:{1} Count:{2}", a, b, n); } num = n * n + a * n + b; } } } sw.Stop(); Console.WriteLine("Elapsed: {0}s, {1}ms", sw.Elapsed.Seconds, sw.Elapsed.Milliseconds); return(A * B); }
static void Main(string[] args) { PrimeGenerator pg = new PrimeGenerator(); double target = 15499d / 94744d; double totient = 1d; double denominator = 1d; long answer = 0; for (int p = 2; ;) { totient *= p - 1; denominator *= p; do { p++; }while (!pg.CheckPrime(p)); if (totient / denominator < target) { for (int j = 1; j < p; j++) { if ((j * totient) / (j * denominator - 1) < target) { answer = j * (long)denominator; Console.WriteLine("Result is {0}", answer); return; } } } } }
// checks if two primes form a "prime pair" static bool isPrimePair(PrimeGenerator pGen, BigInteger a, BigInteger b) { // we need to check that for each possible pair // both possible concatenations also represent a prime number return(pGen.isPrime(BigInteger.Parse("" + a + b)) && pGen.isPrime(BigInteger.Parse("" + b + a))); }
static void Main() { int n = 10; int m = 0; PrimeGenerator p = new PrimeGenerator((int)Math.Floor(Math.Sqrt(300000000))); while (m <= 1000) { m = 0; List <BigInteger> divisors = p.getDivisors(n); // get number of solutions for (int x = 0; x < divisors.Count; ++x) { for (int j = x; j >= 0; --j) { if (p.isCoprime(divisors[x], divisors[j])) { ++m; } } } Console.WriteLine("Number: " + n); Console.WriteLine("Solutions: " + m); ++n; } Console.WriteLine(n); // Keep the console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public void ThreeArray() { int[] array = PrimeGenerator.GeneratePrimes(3); Assert.AreEqual(array.Length, 2); Assert.AreEqual(array[0], 2); Assert.AreEqual(array[1], 3); }
static void Main(string[] args) { nums = new int[Max + 1][]; for (int i = 0; i <= Max; i++) { nums[i] = new int[] { i, 1, i }; } int[] primes = new PrimeGenerator().GetPrimesBelowOneMillion(); for (int i = 0; i <= primes.Length; i++) { int prime = primes[i]; if (prime > Max) { break; } int start = prime; while (start <= Max) { nums[start][1] *= prime; while (nums[start][0] % prime == 0) { nums[start][0] = nums[start][0] / prime; } start += prime; } } var ordered = nums.OrderBy(x => x[1]); int result = ordered.Skip(10000).Take(1).FirstOrDefault()[2]; Console.WriteLine("Result is {0}", result); Console.ReadLine(); }
static void Main() { int search = Convert.ToInt32(Math.Ceiling(Math.Sqrt(Math.Pow(10, 7)))); int search2 = Convert.ToInt32(Math.Ceiling(Math.Pow(10, 7))); PrimeGenerator primeGen = new PrimeGenerator(search); List <BigInteger> primes = primeGen.getPrimes(); double min = search2; int tot = 0; for (int i = 2; i <= search2; ++i) { tot = totient(i, primeGen); if (Permutator.isPermutation(i, tot) && min >= ((double)i) / tot) { Console.WriteLine(i); min = ((double)i) / tot; } } Console.WriteLine("Answer: "); // Keep the console window open in debug mode. Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public static void Main() { PrimeGenerator gen = new PrimeGenerator(); // 소수생성기 인스턴스 생성 //// PrintPrime 콜백 메서드 추가 //PrimeGenerator.PrimeDelegate callprint = PrintPrime; // 소수출력 메소드를 델리게이트로 생성 //gen.AddDelegate(callprint); // 델리게이트로 만든 소수출력 메소드를 소수생성기의 델리게이트와 연결 //// SumPrime 콜백 메서드 추가 //PrimeGenerator.PrimeDelegate callsum = SumPrime; // 소수합 메소드를 델리게이트로 생성 //gen.AddDelegate(callsum); // 델리게이트로 만든 소수합 메소드를 소수생성기의 델리게이트와 연결 gen.PrimeGenerated += PrintPrime; // 이벤트 연결 gen.PrimeGenerated += SumPrime; // 델리게이트보드 간편하다. // 1 ~ 10까지 소수를 구하고, gen.Run(10); // 델리게이트와 연결된 모든 메소드를 동시에 실행 Console.WriteLine(); Console.WriteLine(Sum); // SumPrime 콜백 메서드를 제거한 후 다시 1 ~ 15까지 소수를 구하는 메서드 호출 gen.PrimeGenerated -= SumPrime; // 이벤트 구독 해지 //gen.RemoveDelegate(callsum); // 델리게이트 해지 gen.Run(15); }
static BigInteger getDivisorSum(BigInteger n) { // deal with edge cases if (n <= 1) { return(0); } // populate primegenerator if it already hasn't // been populated if (p == null) { p = new PrimeGenerator(PRIME_BOUND); } // get prime factorization of n List <Tuple <BigInteger, BigInteger> > factorization; factorization = p.getFactorization(n); // calculate the sum of the proper divisors // of n double ret = 1.0; for (int x = 0; x < factorization.Count; ++x) { ret *= (Math.Pow((double)factorization[x].Item1, (double)factorization[x].Item2 + 1) - 1) / (double)(factorization[x].Item1 - 1); } return((BigInteger)(ret - (double)n)); }
private static void Main(string[] args) { var primeGenerator = new PrimeGenerator(); while (true) { Console.Write("Enter count of prime numbers or 'e' to exit: "); var key = Console.ReadLine(); if (key == "e") { break; } int count; bool parseResult = int.TryParse(key, out count); if (!parseResult) { Console.WriteLine("Entered value is invalid"); Console.WriteLine(); continue; } var primeNumbers = primeGenerator.GeneratePrimeNumbres(count); primeNumbers.ToList().ForEach(Console.WriteLine); var sum = primeGenerator.GetSpecialSum(primeNumbers); Console.WriteLine($"Special sum: {sum}"); Console.WriteLine(); } }
public void Test2() { int[] primes = PrimeGenerator.generatePrimes(2); Assert.Equal(1, primes.Length); Assert.Equal(2, primes[0]); }
public void TestExhaustive() { for (int i = 2; i < 500; i++) { VerifyPrimeList(PrimeGenerator.GeneratePrimeNumbers(i)); } }
/// <summary> /// 异步操作的Subject /// </summary> public static void AsyncSubjectConvertTask() { //var tcs = new TaskCompletionSource<bool>(); //var task = tcs.Task; var sbj = new AsyncSubject <string>(); sbj.SubscribeConsole(); var task = PrimeGenerator.GenerateAsync(5); task.ContinueWith(t => { switch (t.Status) { case TaskStatus.RanToCompletion: sbj.OnNext(string.Join(",", t.Result)); sbj.OnCompleted(); break; case TaskStatus.Canceled: sbj.OnError(t.Exception.InnerException); break; case TaskStatus.Faulted: sbj.OnError(new TaskCanceledException(t)); break; } }, TaskContinuationOptions.ExecuteSynchronously); //tcs.SetResult(true); }
public CommandsContainer(Options options, IMainForm mainForm, IEnvironmentHelper environmentHelper, IMessageHelper messageHelper, IFormFactory formFactory) { var primeTest = new RabinMillerTest(20); var primeGenerator = new PrimeGenerator(primeTest); var keyGenerator = new KeyGenerator(new RsaKeyGenerator(), primeGenerator); var fileUnifier = new FileUnifier(); var zipAlgorithm = new ZipAlgorithm(environmentHelper); IRsaFactory rsaFactory = new RsaFactory(new FileFactory(0), options, environmentHelper, zipAlgorithm); AboutProgramCommand = new AboutProgramCommand(formFactory, environmentHelper); CipherCommand = new CipherCommand(this, mainForm.FilesView, formFactory, fileUnifier, environmentHelper, options, rsaFactory, messageHelper); DecipherCommand = new DecipherCommand(this, mainForm.FilesView, rsaFactory, environmentHelper, formFactory, messageHelper, fileUnifier); ExitCommand = new ExitCommand(); GenerateKeysCommand = new GenerateKeysCommand(keyGenerator, options, formFactory, messageHelper); refreshDirectoryCommand = new RefreshDirectoryCommand(messageHelper); toUpperFolderCommand = new ToUpperFolderCommand(messageHelper); changeLanguageCommand = new ChangeLanguageCommand(options); var cryptoViews = new ICryptoView[] { mainForm.MainMenu, mainForm.ToolBar, mainForm.FilesView }; RefreshCryptoViewsCommand = new RefreshCryptoViewsCommand(mainForm.FilesView, cryptoViews); }
public void GetTwoProbablePrimesParallelTest() { BigInteger[] res = PrimeGenerator.GetTwoProbablePrimesParallel(64); Assert.AreEqual(2, res.Length); Assert.IsFalse(res[0] == res[1]); Assert.Pass(string.Join(", ", res)); }
static void Main() { PrimeGenerator primes = new PrimeGenerator(squareSearch); int count = 0; int numPrimes = primes.getSize(); SortedSet <int> check = new SortedSet <int>(); for (int i = 0; i < numPrimes && primes[i] <= squareSearch; ++i) { for (int j = 0; j < numPrimes && primes[j] <= cubeSearch; ++j) { for (int k = 0; k < numPrimes && primes[k] <= fourthPowerSearch; ++k) { int x = (int)(Math.Pow((double)primes[i], 2) + Math.Pow((double)primes[j], 3) + Math.Pow((double)primes[k], 4)); if (x <= search && !check.Contains(x)) { check.Add(x); count++; } } } } Console.WriteLine(count); Console.WriteLine("Press any key to exit."); Console.ReadKey(); }
public Principal(string name, int generator, int modulus) { Console.WriteLine($"Creating principal {name}..."); Name = name; Generator = generator; Modulus = modulus; _secret = PrimeGenerator.GetPrime(); SecretMessage = SquareAndMultiply.Calculate(Generator, _secret, Modulus); Console.WriteLine($"{Name} has selected a secret: {_secret}"); Console.WriteLine($"{Name} calculated its secret message ({Generator}^{_secret}) mod {modulus}: {SecretMessage}"); rsa = new RSACryptoServiceProvider(2048); _publicKey = rsa.ExportParameters(false); _privateKey = rsa.ExportParameters(true); Console.WriteLine($"{Name} created 2048 bit RSA public and private keys"); RSAPublicKeyStore.AddPublicKey(Name, _publicKey); _secretMessages = new Dictionary <string, int>(); _symmetricKeys = new Dictionary <string, string>(); _authorizedPrincipals = new HashSet <string>(); Console.WriteLine($"Principal {Name} has been created successfully.\r\n"); }
/// <summary> /// Solve the Prime solution /// </summary> /// <returns></returns> public long Solve() { long count, num, total = 0; int index = 0; pg = new PrimeGenerator(LIMIT, out count); TruncablePrimes = new List <long>(); Dictionary <long, List <long> > primes = pg.CreateBlocks(LIMIT, BLOCK_SIZE); num = pg.Primes[index]; while (total != 11) { if (num > 10) { if (TruncRight(num, primes) && TruncLeft(num, primes)) { total++; this.TruncablePrimes.Add(num); Console.WriteLine(String.Format("Index: {0}, Num{1}", total, num)); } } index++; num = pg.Primes[index]; } return(this.TruncablePrimes.Sum()); }
public void SieveOfEratosthenesTest() { List <int> primes = PrimeGenerator.SieveOfEratosthenes(2741); Assert.AreEqual(400, primes.Count); CollectionAssert.AreEqual(PrimeGenerator.Primes, primes); }
public void Can_Return_Values_Comma_Delimited() { var primeGenerator = new PrimeGenerator(new PrimeEvaluationEngine()); string actual = primeGenerator.GeneratePrimesUpTo(10); Assert.AreEqual("2,3,5,7,9", actual); }
public async Task Current_throws_before_first() { var generator = new PrimeGenerator(); await using var enumerator = generator.GetAsyncEnumerator(); enumerator.Invoking(e => e.Current).Should().Throw <InvalidOperationException>("you cannot get current before move next"); }
public void SieveFirstPrime() { var firstPrime = 2; var sieve = PrimeGenerator.GetPrimeEnumeratorEratosthenes(2); sieve.MoveNext(); Assert.IsTrue(sieve.Current == firstPrime); }
public void TestPrimeNumbersLessThan(int number, IEnumerable <int> expected) { var primeGenerator = new PrimeGenerator(); var primes = primeGenerator.LessThen(number); Assert.Equal(expected, primes); }
public void GenerateFrom_NumberIsEven() { generator = new PrimeGenerator(new RabinMillerTest(BigNumber.FromBytes(new[] { 2 }))); var number = BigNumber.FromBytes(new[] { 14 }); var simple = generator.GenerateFrom(number); CheckNumber(simple, 17); }
static void Main(string[] args) { var pg = new PrimeGenerator(); var int_pairs = new int_pair[] { new int_pair { Int1 = 1, Int2 = 1_000_000 },
public void GenerateFrom_StartNumberIs133() { generator = new PrimeGenerator(new RabinMillerTest(CreateWitnesses(2, 132))); var number = BigNumber.FromBytes(new[] { 133 }); var simple = generator.GenerateFrom(number); CheckNumber(simple, 137); }
public void Should_Throw_Exception_If_Greater_Than_IntMax(int num) { //assemble var generator = new PrimeGenerator(); //act && assert Assert.Throws <Exception>(() => generator.PrimeNumberGenerator(Int32.MaxValue)); }
public void Test4() { int[] primes = PrimeGenerator.generatePrimes(4); Assert.Equal(2, primes.Length); Assert.Equal(2, primes[0]); Assert.Equal(3, primes[1]); }
public void SetUp() { rsaKeyGenerator = new RsaKeyGenerator(); var rabinMillerTest = new RabinMillerTest(20); primeGenerator = new PrimeGenerator(rabinMillerTest); keyGenerator = new KeyGenerator(rsaKeyGenerator, primeGenerator); }
public void Should_Return_Values_Comma_Delimited() { var primeGenerator = new PrimeGenerator(new PrimeEvaluationEngine()); var actual = primeGenerator.GeneratePrimesUpTo(10); Assert.That(actual, Is.EqualTo("2,3,5,7,9")); }
public void RandomOddIntegerTest() { for (var i = 0; i < 5; i++) { BigInteger bi = PrimeGenerator.RandomOddBigInteger(512); Assert.IsTrue(!bi.IsEven); } }
public void Should_Contains_Count_For_Every_Tenth_Line() { var generatedPrimes = new PrimeGenerator(new PrimeEvaluationEngine()).GeneratePrimesUpTo(2000); var outputFormatter = new OutputFormatter(); var formattedOutput = outputFormatter.Format(generatedPrimes); for (var i = 10; i < formattedOutput.Count; i += 11) { Assert.That(formattedOutput[i].Contains("Count:")); } }
public void Test_ZKProtocol_ComputeProof() { int fieldSize = 1024 / 8; int base1 = 3; int base2 = 5; int secret = 7; int result1 = base1 ^ secret; int result2 = base2 ^ secret; byte[] r = null; byte[] c = null; PrimeGenerator pg = new PrimeGenerator(); var prime = pg.GenerateRandomPrime(fieldSize); NonInteractiveChaumPedersen ncp = new NonInteractiveChaumPedersen(prime); ncp.ComputeProofs(BitConverter.GetBytes(base1), BitConverter.GetBytes(base2), BitConverter.GetBytes(result1) , BitConverter.GetBytes(result2), BitConverter.GetBytes(secret), ref r, ref c); Assert.IsNotNull(r); Assert.IsNotNull(c); }
public void Should_Return_Empty_String() { var primeGenerator = new PrimeGenerator(new PrimeEvaluationEngine()); Assert.That(primeGenerator.GeneratePrimesUpTo(0), Is.EqualTo(string.Empty)); }
public static extern IntPtr BN_generate_prime(IntPtr ret, int bits, int safe, IntPtr add, IntPtr rem, PrimeGenerator cb, IntPtr cb_args);
public void _TestFixtureSetUp() { _generatedPrimes = new PrimeGenerator(new PrimeEvaluationEngine()).GeneratePrimesUpTo(20); }