Esempio n. 1
0
        public static void DoSomeReflectionStuff()
        {
            // Find all implementations of the IRandom interface in the ProgramFlow assembly.
            Assembly a       = Assembly.Load("ProgramFlow");
            var      randoms = from type in a.GetTypes()
                               where typeof(IRandom).IsAssignableFrom(type) && !type.IsInterface
                               select type;


            IRandom random = null;

            // Create an instance of each of the implementations found.
            foreach (Type t in randoms)
            {
                random = Activator.CreateInstance(t) as IRandom;
                Console.WriteLine(random.GetRandomString());
            }



            // Using reflection to get a private field from a calss in antoher assembly
            FieldInfo[] fields = random.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic);
            foreach (var field in fields)
            {
                if (field.FieldType == typeof(int))
                {
                    Console.WriteLine(field.GetValue(random));
                }
            }
        }
Esempio n. 2
0
 protected Board(int rows, int columns, List <Point> directions, IRandom random)
 {
     _values = new Status[rows, columns];
     Reset();
     CountPawns();
     InitTriplets(directions);
     Random = random;
     Console.WriteLine($"Init board with {random.GetType()} (seed={random.InitialSeed}) (Pawns={Pawns})");
 }
Esempio n. 3
0
        /// <summary>
        /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng
        /// </summary>
        ///
        /// <param name="CipherParams">The RLWEParameters instance containing the cipher settings</param>
        /// <param name="RngEngine">An initialized Prng instance</param>
        /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param>
        public RLWEKeyGenerator(RLWEParameters CipherParams, IRandom RngEngine, bool Parallel = true)
        {
            m_rlweParams = CipherParams;
            m_rndEngine  = RngEngine;
            m_frcLinear  = ParallelUtils.ForceLinear;

            // passphrase gens must be linear processed
            if (RngEngine.GetType().Equals(typeof(PBPRng)))
            {
                ParallelUtils.ForceLinear = true;
            }
            else
            {
                ParallelUtils.ForceLinear = !Parallel;
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng
        /// </summary>
        ///
        /// <param name="CipherParams">The NTRUParameters instance containing the cipher settings</param>
        /// <param name="RngEngine">An initialized Prng instance</param>
        /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param>
        public NTRUKeyGenerator(NTRUParameters CipherParams, IRandom RngEngine, bool Parallel = true)
        {
            this.m_frcLinear = ParallelUtils.ForceLinear;
            // passphrase gens must be linear processed
            if (RngEngine.GetType().Equals(typeof(PBPRng)))
            {
                ParallelUtils.ForceLinear = true;
            }
            else
            {
                ParallelUtils.ForceLinear = !Parallel;
            }

            this.m_ntruParams = CipherParams;
            // set source of randomness
            this.m_rndEngine = RngEngine;
        }
        private static void CalculateTestValues(IRandom random, string operationName, System.Action <IRandom, BinaryWriter> writeTestValue, int testValueCount)
        {
            string dataFileName = string.Format(dataFilePathTemplate, random.GetType().Name, operationName);
            string dataFilePath = Path.GetFullPath("Packages/com.andygainey.makeit.random/Tests/Editor/Random/Data~/");

            using (var file = File.Open(Path.Combine(dataFilePath, dataFileName), FileMode.Create, FileAccess.Write))
            {
                using (var writer = new BinaryWriter(file))
                {
                    var state = random.SaveState();
                    writer.Write(state.Length);
                    writer.Write(state);
                    writer.Write(testValueCount);
                    for (int i = 0; i < testValueCount; ++i)
                    {
                        writeTestValue(random, writer);
                    }
                }
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng
        /// </summary>
        ///
        /// <param name="CipherParams">The RLWEParameters instance containing the cipher settings</param>
        /// <param name="RngEngine">An initialized Prng instance</param>
        /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param>
        public MPKCKeyGenerator(MPKCParameters CipherParams, IRandom RngEngine, bool Parallel = true)
        {
            _mpkcParams = (MPKCParameters)CipherParams;
            // set source of randomness
            _rndEngine = RngEngine;
            _M         = _mpkcParams.M;
            _N         = _mpkcParams.N;
            _T         = _mpkcParams.T;
            _fieldPoly = _mpkcParams.FieldPolynomial;

            _frcLinear = ParallelUtils.ForceLinear;
            // passphrase gens must be linear processed
            if (RngEngine.GetType().Equals(typeof(PBPRng)))
            {
                ParallelUtils.ForceLinear = true;
            }
            else
            {
                ParallelUtils.ForceLinear = !Parallel;
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng
        /// </summary>
        /// 
        /// <param name="CipherParams">The NTRUParameters instance containing the cipher settings</param>
        /// <param name="RngEngine">An initialized Prng instance</param>
        /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param>
        public NTRUKeyGenerator(NTRUParameters CipherParams, IRandom RngEngine, bool Parallel = true)
        {
            _frcLinear = ParallelUtils.ForceLinear;
            // passphrase gens must be linear processed
            if (RngEngine.GetType().Equals(typeof(PBPRng)))
                ParallelUtils.ForceLinear = true;
            else
                ParallelUtils.ForceLinear = !Parallel;

            _ntruParams = CipherParams;
            // set source of randomness
            _rndEngine = RngEngine;
        }
Esempio n. 8
0
        /// <summary>
        /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng
        /// </summary>
        /// 
        /// <param name="CipherParams">The RLWEParameters instance containing the cipher settings</param>
        /// <param name="RngEngine">An initialized Prng instance</param>
        /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param>
        public MPKCKeyGenerator(MPKCParameters CipherParams, IRandom RngEngine, bool Parallel = true)
        {
            _mpkcParams = (MPKCParameters)CipherParams;
            // set source of randomness
            _rndEngine = RngEngine;
            _M = _mpkcParams.M;
            _N = _mpkcParams.N;
            _T = _mpkcParams.T;
            _fieldPoly = _mpkcParams.FieldPolynomial;

            _frcLinear = ParallelUtils.ForceLinear;
            // passphrase gens must be linear processed
            if (RngEngine.GetType().Equals(typeof(PBPRng)))
                ParallelUtils.ForceLinear = true;
            else
                ParallelUtils.ForceLinear = !Parallel;
        }
Esempio n. 9
0
        /// <summary>
        /// Use an initialized prng to generate the key; use this constructor with an Rng that requires pre-initialization, i.e. PBPrng
        /// </summary>
        /// 
        /// <param name="CipherParams">The RLWEParameters instance containing the cipher settings</param>
        /// <param name="RngEngine">An initialized Prng instance</param>
        /// <param name="Parallel">Use parallel processing when generating a key; set to false if using a passphrase type generator (default is true)</param>
        public RLWEKeyGenerator(RLWEParameters CipherParams, IRandom RngEngine, bool Parallel = true)
        {
            _rlweParams = CipherParams;
            _rndEngine = RngEngine;
            _frcLinear = ParallelUtils.ForceLinear;

            // passphrase gens must be linear processed
            if (RngEngine.GetType().Equals(typeof(PBPRng)))
                ParallelUtils.ForceLinear = true;
            else
                ParallelUtils.ForceLinear = !Parallel;
        }