/// <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);
}
