AdamWhiteHat

using System;
using System.Linq;
using System.Collections;
using System.ComponentModel;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Collections.ObjectModel;
using System.Runtime.CompilerServices;

AdamWhiteHat

public static class GenericArithmeticFactory<T>
{
    private static Dictionary<ExpressionType, Func<T, T, T>> _binaryOperationDictionary;
    private static Dictionary<ExpressionType, Func<T, T, bool>> _comparisonOperationDictionary;
    private static Func<T, T> _sqrtOperation = null;

    static GenericArithmeticFactory()
    {
        _binaryOperationDictionary = new Dictionary<ExpressionType, Func<T, T, T>>();
        _comparisonOperationDictionary = new Dictionary<ExpressionType, Func<T, T, bool>>();

AdamWhiteHat

/// <summary>
/// Requires the BCrypt nuget package. Available here: https://www.nuget.org/packages/BCrypt.Net-Next
/// </summary>
public static class PasswordHashing
{
	public static string HashPassword(string password, int workFactor)
	{
		return BCrypt.Net.BCrypt.HashPassword(password, workFactor);
	}

AdamWhiteHat

public static class FastFactorial
{
	public static BigInteger Factorial(BigInteger n)
	{
		return MultiplyRange(2, n);
	}

	private static BigInteger MultiplyRange(BigInteger from, BigInteger to)
	{
		var diff = to - from;

AdamWhiteHat

using System;
using System.Linq;
using System.Numerics;
using System.Collections.Generic;

public static class Maths
{
	/// <summary>
	/// Legendre Symbol returns 1 for a (nonzero) quadratic residue mod p, -1 for a non-quadratic residue (non-residue), or 0 on zero.
	/// </summary>

AdamWhiteHat

/// <summary>
/// Cryptographically secure random number generator. Features a safe, secure, and correct implementation.
/// Numbers are evenly distributed across the whole range; avoids modulo bias.
/// Internal buffers always cleared after every value returned--leaves nothing in memory.
/// Singleton intended to be instantiated only once for the lifetime of the application.
/// Remember to call Dispose when no longer needed.
/// </summary>
public static class CryptoRandomSingleton
{

AdamWhiteHat

public class ANS1PrivateKey : IDisposable
{
	public BigInteger Modulus = BigInteger.MinusOne;
	public BigInteger Exponent = BigInteger.MinusOne;
	public BigInteger P = BigInteger.MinusOne;
	public BigInteger Q = BigInteger.MinusOne;
	public BigInteger D = BigInteger.MinusOne;
	public BigInteger DP = BigInteger.MinusOne;
	public BigInteger DQ = BigInteger.MinusOne;
	public BigInteger InverseQ = BigInteger.MinusOne;

AdamWhiteHat

using System.Numerics;

public static class Factorization
{
    private static BigInteger _cacheCeiling;
    private static List<BigInteger> _primeCache;
    private static BigInteger _cacheLargestPrimeCurrently;
    private static BigInteger[] _probablePrimeCheckBases;

    static Factorization()

AdamWhiteHat

public static class PrimeFactory
{
    private static BigInteger _cacheLargestPrimeCurrently;
    private static BigInteger _cacheCeiling;
    internal static BigInteger[] _primeCache;

    static PrimeFactory()
    {
        _cacheCeiling = BigInteger.Pow(11, 7);
        _primeCache = new BigInteger[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };

AdamWhiteHat

public static class Eratosthenes
{
    public static IEnumerable<BigInteger> Sieve(Int64 maxValue)
    {
        if (maxValue < 10)
        {
            if (maxValue == 9 || maxValue == 8 || maxValue == 7)
            {
                return new List<BigInteger>() { 2, 3, 5, 7 };
            }