public SecureRandom(
byte[] inSeed)
: base(0)
{
this.generator = new DigestRandomGenerator(new Sha1Digest());
SetSeed(inSeed);
}
public Player(IRandomGenerator generator, IBoard gameBoard, string name = "")
{
Generator = generator;
GameBoard = gameBoard;
Name = name;
Position = 0;
}
public override void Train(IList<InputOutput> trainingSet,
IList<InputOutput> validationSet,
IRandomGenerator rand,
INeuralNetwork nn)
{
var prevWeightGradients = nn.Weights.DeepClone();
foreach (var gradSet in prevWeightGradients)
{
for (var j = 0; j < gradSet.Length; j++)
gradSet[j] = 0;
}
for (var s = 0; s < NumEpochs; s++)
{
var t = rand.Next(trainingSet.Count);
var inputOutput = trainingSet[t];
var batch = GetBatch(trainingSet, BatchSize, rand);
var gradients = nn.Weights.DeepCloneToZeros();
for (var j = 0; j < BatchSize; j++)
{
gradients.AddInPlace(
nn.CalculateGradients(batch[j].Input.AddRelativeNoise(MaxRelativeNoise, rand), batch[j].Output));
}
gradients.MultiplyInPlace(1 / ((double)BatchSize));
//var gradients = nn.CalculateGradients(inputOutput.Input, inputOutput.Output);
AdjustWeights(nn, gradients, prevWeightGradients);
gradients.DeepCopyTo(prevWeightGradients);
}
}
public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
{
var employeeIds = data.Employees.Select(x => x.EmployeeId);
var projectIds = data.Projects.Select(x => x.ProjectId).ToList();
foreach (var employee in employeeIds)
{
var employeeProjects = random.GetRandomNumber((int)count / 2, (int)(count * 1.5));
for (var i = 0; i < employeeProjects; i++)
{
var projectId = projectIds[random.GetRandomNumber(1, projectIds.Count - 1)];
var startDate = DateTime.Now.AddDays(-random.GetRandomNumber(-500, 1000));
var endDate = startDate.AddDays(random.GetRandomNumber(1, 1234));
var employeeInProj = new Employees_Projects
{
ProjectId = projectId,
Startdate = startDate,
Enddate = endDate,
EmployeeId = employee
};
data.Employees_Projects.Add(employeeInProj);
}
}
}
/// <summary>
/// Initializes a new instance of the DefaultFieldRandomizer class.
/// </summary>
/// <param name="randomGenerator">The random generator.</param>
public DefaultFieldRandomizer(IRandomGenerator randomGenerator)
{
Validation.ThrowIfNull(randomGenerator);
this._randomGenerator = randomGenerator;
this._totalElementsInDirection = Enum.GetNames(typeof(Direction)).Length;
}
public void Setup()
{
_udp = MockRepository.GenerateMock<IStatsdUDP>();
_randomGenerator = MockRepository.GenerateMock<IRandomGenerator>();
_randomGenerator.Stub(x => x.ShouldSend(Arg<double>.Is.Anything)).Return(true);
_stopwatch = MockRepository.GenerateMock<IStopWatchFactory>();
}
public void SetUp()
{
var builderSetup = new BuilderSettings();
reflectionUtil = Substitute.For<IReflectionUtil>();
generator = Substitute.For<IRandomGenerator>();
propertyNamer = new RandomValuePropertyNamer(generator, reflectionUtil, false,builderSetup);
}
public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
{
var employeeIds = data.Employees.Select(e => e.Id).ToList();
var projectIds = data.Projects.Select(p => p.Id).ToList();
foreach (var employeeId in employeeIds)
{
var employeeProjectsCount = random.GetRandomNumber((int)(count * 0.5), (int)(count * 1.5));
var currentProjects = new HashSet<int>();
while (currentProjects.Count < employeeProjectsCount)
{
var randomProjectId = projectIds[random.GetRandomNumber(0, projectIds.Count - 1)];
currentProjects.Add(randomProjectId);
}
foreach (var projectId in currentProjects)
{
var endDateTimeSpan = random.GetRandomNumber(-500, 1000);
var startDateTimeSpan = endDateTimeSpan + random.GetRandomNumber(1, 500);
data.EmployeesInProjects.Add(new EmployeesInProject
{
EmployeeId = employeeId,
ProjectId = projectId,
StartDate = DateTime.Now.AddDays(-startDateTimeSpan),
EndDate = DateTime.Now.AddDays(-endDateTimeSpan)
});
}
}
}
public override void Initialize()
{
randomGenerator = GameServiceManager.GetService<IRandomGenerator>();
ResetTimer();
base.Initialize();
}
public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
{
var allAddedEmployees = new List<Employee>();
var departmentIds = data.Departments.Select(d => d.Id).ToList();
for (int i = 0; i < count; i++)
{
var employee = new Employee
{
FirstName = random.GetRandomString(random.GetRandomNumber(5, 20)),
LastName = random.GetRandomString(random.GetRandomNumber(5, 20)),
Salary = random.GetRandomNumber(50000, 200000),
DepartmentId =
departmentIds[random.GetRandomNumber(0, departmentIds.Count - 1)]
};
if (allAddedEmployees.Count > 0 && random.GetRandomNumber(1, 100) <= 95)
{
employee.Employee1 = allAddedEmployees[random.GetRandomNumber(0, allAddedEmployees.Count - 1)];
}
allAddedEmployees.Add(employee);
}
data.Employees.AddRange(allAddedEmployees);
}
public PinkNoise(IRandomGenerator randomGenerator, float rmsAmplitude)
{
if (null == randomGenerator)
throw new ArgumentNullException("randomGenerator");
_whiteGenerator = new NormalDistribution(randomGenerator, 0, RmsScale * rmsAmplitude);
}
public void GenerateData(MongoDatabase db, IRandomGenerator random, int count)
{
string name;
decimal price;
int? upgradeToId;
List<MongoUpgrade> mongoUpgrades = new List<MongoUpgrade>();
for (int i = 0; i < count; i++)
{
name = random.GetRandomString(random.GetRandomNumber(5, 50));
price = (decimal)(random.GetRandomNumber(10000, 1000000) / 100);
upgradeToId = i;
if(i % 4 == 0)
{
upgradeToId = null;
}
var upgrade = new MongoUpgrade(name, price, upgradeToId);
mongoUpgrades.Add(upgrade);
}
MongoCollection<MongoUpgrade> upgrades = db.GetCollection<MongoUpgrade>("Upgrades");
upgrades.InsertBatch(mongoUpgrades);
}
public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
{
for (int i = 0; i < count; i++)
{
var project = new Project { Name = random.GetRandomString(random.GetRandomNumber(5, 50)) };
data.Projects.Add(project);
}
}
public Person(IRandomGenerator random, List<IGene> genes, bool isFemale)
{
_random = random;
_personId = Guid.NewGuid();
_age = 0;
_isFemale = isFemale;
_genes = genes;
}
public Roulette(IRandomGenerator randomGenerator)
{
if (RunningGames == null)
{
RunningGames = new Dictionary<string, Game>();
}
_randomGenerator = randomGenerator;
}
/// <summary>
/// Returns a random number generator.
/// </summary>
/// <returns></returns>
public static IRandomGenerator Get()
{
if (_generator == null)
{
_generator = new RandomGenerator();
}
return _generator;
}
/// <summary>
/// Initializes a new instance of the <see cref="Board" /> class.
/// Board object containing multiple Balloon objects. The Board serves as the interface through which Balloons are accessed.
/// </summary>
/// <param name="rows">The max amount of rows the board will contain.</param>
/// <param name="cols">The max amount of columns the board will contain.</param>
/// <param name="randomGenerator">The random generator on which depends the balloons' randomness.</param>
public Board(int rows, int cols, IRandomGenerator randomGenerator)
{
this.Rows = rows;
this.Cols = cols;
this.board = new IBalloon[this.Rows, this.Cols];
this.RandomGenerator = randomGenerator;
this.balloonFactory = new BalloonFactory();
this.Fill();
}
public override void Initialize()
{
var health = ParentGameObject.GetComponent<IHealthComponent>();
health.OnHealthDepleted += HealthOnOnHealthDepleted;
randGen = GameServiceManager.GetService<IRandomGenerator>();
base.Initialize();
}
//========================= Misc public helpers =========================
public static void InitializeWeights(INeuralNetwork nn, IRandomGenerator rand)
{
var weights = nn.Weights;
foreach (var weightsSubList in weights)
{
for (int i = 0; i < weightsSubList.Length; i++)
weightsSubList[i] = rand.NextDouble() - 0.5;
}
}
public World(IPopulation pop, IPersonFactory pf, IRandomGenerator random, IMortalityCurve mc)
{
_mortalityCurve = mc;
_registeredGenes = new GeneBank(this);
WorldSeeds.BaseGenes(_registeredGenes, this);
_population = pop;
_personFactory = pf;
_random = random;
SeedWorld(1001);
}
public ReversedWindowGenerator(IRandomGenerator generator, int windowSize)
{
if (generator == null)
throw new ArgumentNullException("generator");
if (windowSize < 2)
throw new ArgumentException(@"Window size must be at least 2", "windowSize");
_generator = generator;
_window = new byte[windowSize];
}
/// <summary>
/// Initializes a new instance of the <see cref="GameField" /> class.
/// </summary>
/// <param name="random">Random generator.</param>
/// <param name="mineFactory">Mine factory.</param>
/// <param name="size">Size of the game field.</param>
/// <param name="isExplosionChained">True if there is explosions chaining.</param>
public GameField(IRandomGenerator random, IMineFactory mineFactory, int size, bool isExplosionChained = false)
{
this.random = random;
this.mineFactory = mineFactory;
this.field = new Cell[size, size];
this.MinesCount = this.CalculateInitialMineCount();
this.FillFieldWithEmptyCells();
this.FillFieldMines();
this.isExplosionChained = isExplosionChained;
}
public RandomFilesEnumerator(List<FileInfo> filesList)
{
if (filesList == null)
{
throw new ArgumentNullException("filesList");
}
this.filesList = filesList;
this.randomGenerator = new RandomGenerator();
}
public SampleDataGenerator(double minValueToGenerate,
double maxNonPeakValueToGenerate, double minPeakValueToGenerate,
int peakInterval, IRandomGenerator randomGenerator)
{
if (minValueToGenerate >= maxNonPeakValueToGenerate)
{
throw new ArgumentOutOfRangeException(
"maxNonPeakValueToGenerate",
maxNonPeakValueToGenerate,
"maxNonPeakValueToGenerate must be greater than minValueToGenerate.");
}
if ((minPeakValueToGenerate != 0) &&
(maxNonPeakValueToGenerate >= minPeakValueToGenerate))
{
throw new ArgumentOutOfRangeException(
"minPeakValueToGenerate",
minPeakValueToGenerate,
"If not 0, minPeakValueToGenerate must be greater than maxNonPeakValueToGenerate.");
}
// minPeakValueToGenerate is zero when peaks are not generated
_generatePeaks = minPeakValueToGenerate != 0 ? true : false;
if (_generatePeaks && peakInterval == 0)
{
throw new ArgumentOutOfRangeException("peakInterval", "peakInterval cannot be 0.");
}
if (randomGenerator == null)
{
throw new ArgumentNullException("randomGenerator");
}
_minValueToGenerate = minValueToGenerate;
_maxNonPeakValueToGenerate = maxNonPeakValueToGenerate;
// Scale up to ensure we exceed rather than equal threshold in all cases
_minPeakValueToGenerate = minPeakValueToGenerate * 1.01;
_peakInterval = peakInterval;
// Start in the middle of the range
_startValue = ((_maxNonPeakValueToGenerate - _minValueToGenerate) / 2.0) + _minValueToGenerate;
_nextValue = _startValue;
_deltaValue = (_maxNonPeakValueToGenerate - _minValueToGenerate) * _maximumFractionToChangePerTick;
_thresholdWidth = (_minPeakValueToGenerate - _minValueToGenerate);
_tickCounter = 1;
_randomGenerator = randomGenerator;
}
private static UnitCollectionsModel GenerateData(IRandomGenerator generator, IDataGenerator randomGenerator)
{
var generatedData = new UnitCollectionsModel()
{
Songs = randomGenerator.GenerateSongs(generator, 20),
Albums = randomGenerator.GenerateAlbums(generator, 20),
Artists = randomGenerator.GenerateArtists(generator, 20)
};
return generatedData;
}
/// <summary>
/// Generate a key pair.
/// </summary>
/// <param name="keygen">an instance of IAsymmetricCipherKeyPairGenerator</param>
/// <param name="keySize">iKeySize Key size of key pair</param>
/// <param name="random">an instance of IRandomGenerator</param>
/// <returns>A key pair</returns>
public static AsymmetricCipherKeyPair GenerateKeyPair(IAsymmetricCipherKeyPairGenerator keygen, int keySize, IRandomGenerator random)
{
// Create a SecureRandom
var rand = new SecureRandom(random);
// Initialize key pair generator with key strength and a randomness
keygen.Init(new KeyGenerationParameters(rand, keySize));
// Generate and return the key pair
return keygen.GenerateKeyPair();
}
public HeightmapTextureProcessor(IHeightmapPage heightmapPage,
ITextureGroupResolver textureGroupResolver,
ITextureGroupTransitionRepository textureGroupTransitionRepository,
IRandomGenerator randomGenerator)
{
_heightmapPage = heightmapPage;
_textureGroupResolver = textureGroupResolver;
_textureGroupTransitionRepository = textureGroupTransitionRepository;
_randomGenerator = randomGenerator;
_textures = new Lazy<short[,]>(InitializeTextures);
}
public void Setup()
{
generator = new RandomGeneratorMoc();
string[] properties =
{
"a", "b", "c", "d", "e"
};
gameBoard = new Board(new PropertyFactory(properties));
player = new Player(generator, gameBoard);
}
public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
{
for (var i = 0; i < count; i++)
{
var department = new Department
{
Name = random.GetRandomString(random.GetRandomNumber(10, 50))
};
data.Departments.Add(department);
}
}
public World(IPopulation pop, IPersonFactory pf, IMortalityCurve mortalityCurve, IRandomGenerator random)
{
if (pop?.Populus?.Count > 0) pop.Populus.Clear();
_random = random;
_population = pop;
_registeredGenes = new GeneBank(this);
_personFactory = pf;
_mortalityCurve = mortalityCurve;
WorldSeeds.BaseGenes(_registeredGenes, this);
SeedWorld(1000);
_population?.UpdatePopulus();
}
public GetUsuarioLoginHandler(IBreadingBreadDbContext db, IDateTime dateTime, IRandomGenerator randomGenerator)
{
this.db = db;
this.dateTime = dateTime;
this.randomGenerator = randomGenerator;
}
/// <summary>
/// </summary>
public WPFXamlDefinition(IRandomGenerator randomGenerator)
{
Initialize(randomGenerator, -1, -1, -1, -1);
}
private ISpan StartSpanInternal(
ISpanContext parent,
bool hasRemoteParent,
string name,
ISampler sampler,
IEnumerable <ISpan> parentLinks,
bool recordEvents,
Timer timestampConverter)
{
ITraceParams activeTraceParams = this.Options.TraceConfig.ActiveTraceParams;
IRandomGenerator random = this.Options.RandomHandler;
ITraceId traceId;
ISpanId spanId = SpanId.GenerateRandomId(random);
ISpanId parentSpanId = null;
TraceOptionsBuilder traceOptionsBuilder;
if (parent == null || !parent.IsValid)
{
// New root span.
traceId = TraceId.GenerateRandomId(random);
traceOptionsBuilder = TraceOptions.Builder();
// This is a root span so no remote or local parent.
// hasRemoteParent = null;
hasRemoteParent = false;
}
else
{
// New child span.
traceId = parent.TraceId;
parentSpanId = parent.SpanId;
traceOptionsBuilder = TraceOptions.Builder(parent.TraceOptions);
}
traceOptionsBuilder.SetIsSampled(
MakeSamplingDecision(
parent,
hasRemoteParent,
name,
sampler,
parentLinks,
traceId,
spanId,
activeTraceParams));
TraceOptions traceOptions = traceOptionsBuilder.Build();
SpanOptions spanOptions = SpanOptions.None;
if (traceOptions.IsSampled || recordEvents)
{
spanOptions = SpanOptions.RecordEvents;
}
ISpan span = Span.StartSpan(
SpanContext.Create(traceId, spanId, traceOptions, parent?.Tracestate ?? Tracestate.Empty),
spanOptions,
name,
parentSpanId,
hasRemoteParent,
activeTraceParams,
this.Options.StartEndHandler,
timestampConverter);
LinkSpans(span, parentLinks);
span.Kind = this.Kind;
return(span);
}
public PlayerDeque(IRandomGenerator generator, IPlayerFactory playerFactory) : base(playerFactory.GeneratePlayers())
{
_generator = generator;
Shuffle();
}
/// <summary>
/// 初始化路径生成器
/// </summary>
/// <param name="randomGenerator">随机数生成器</param>
protected PathGeneratorBase(IRandomGenerator randomGenerator)
{
Parameters = new Dictionary <string, string>();
_randomGenerator = randomGenerator ?? GuidRandomGenerator.Instance;
}
public Statsd(IStatsdUDP udp, IRandomGenerator randomGenerator, IStopWatchFactory stopwatchFactory, string prefix)
: this(udp, randomGenerator, stopwatchFactory, prefix, null)
{
}
public Vector3 Next(IRandomGenerator generator)
{
return(new Vector3(_dX.Next(generator), _dY.Next(generator), _dZ.Next(generator)));
}
public RandomOtpGenerator(int otpLength, IRandomGenerator randomGenerator)
{
_otpLength = otpLength;
_randomGenerator = randomGenerator;
}
public AddToRandomTest(IRandomGenerator generateRandom)
{
_generator = generateRandom;
}
public FileService(IRandomGenerator random, IOptions <FileServiceOptions> options)
{
this.random = random;
this.settings = options.Value;
}
public Statsd(IStatsdUDP udp, IRandomGenerator randomGenerator, IStopWatchFactory stopwatchFactory)
: this(udp, randomGenerator, stopwatchFactory, string.Empty)
{
}
/// <summary>Use the specified instance of IRandomGenerator as random source.</summary>
/// <remarks>
/// This constructor performs no seeding of either the <c>IRandomGenerator</c> or the
/// constructed <c>SecureRandom</c>. It is the responsibility of the client to provide
/// proper seed material as necessary/appropriate for the given <c>IRandomGenerator</c>
/// implementation.
/// </remarks>
/// <param name="generator">The source to generate all random bytes from.</param>
public SecureRandom(IRandomGenerator generator)
: base(0)
{
this.generator = generator;
}
public AddCitizenCommand(ICommandCenter commandCenter, ICharacterFactory characterFactory, IValidator validator, IRandomGenerator random)
: base(commandCenter, characterFactory, validator, random)
{
}
public CreateUsuarioHandler(IBreadingBreadDbContext db, IMediator mediator, IDateTime dateTime, IRandomGenerator randomGenerator)
{
this.mediator = mediator;
this.db = db;
this.dateTime = dateTime;
this.randomGenerator = randomGenerator;
}
public RecuperaPasswordGeneraTokenHandler(IBreadingBreadDbContext db, IRandomGenerator random, IMediator mediator)
{
this.db = db;
this.random = random;
this.mediator = mediator;
}
/// <summary>
/// 初始化路径生成器
/// </summary>
/// <param name="basePath">基路径</param>
/// <param name="randomGenerator">随机数生成器</param>
public DefaultPathGenerator(IBasePath basePath, IRandomGenerator randomGenerator = null) : base(randomGenerator)
{
_basePath = basePath;
}
public SimpsonSequenceGenerator(IRandomGenerator randomGenerator) : base(randomGenerator)
{
}
public Inventory_RemoveItem_Event(IPathfinder pathfindingService, IItemInstanceDtoFactory itemFactory, IRandomGenerator randomGenerator)
{
_pathFinder = pathfindingService;
_itemFactory = itemFactory;
_random = randomGenerator;
}
public StringGeneration(IRandomGenerator randomGenerator, GetStringParametersValidator validator)
{
_randomGenerator = randomGenerator;
_validator = validator;
}
public static IRandomGenerator Truncate(this IRandomGenerator gen, double?min = null, double?max = null)
{
return(new TruncatedRandom(gen, min, max));
}
public PersonSeeder(IRandomGenerator randomGenerator)
{
_randomGenerator = randomGenerator;
}
public UserRankingService(IRandomGenerator randomGenerator, IUserRankingRepository repository)
{
_randomGenerator = randomGenerator;
_repository = repository;
}
/// <summary> /// 初始化一个<see cref="DefaultPathGenerator"/>类型的实例 /// </summary> /// <param name="basePath">基路径</param> /// <param name="randomGenerator">随机数生成器</param> public DefaultPathGenerator(IBasePath basePath, IRandomGenerator randomGenerator) : base(randomGenerator) => _basePath = basePath;
/// <summary>
/// 初始化路径生成器
/// </summary>
/// <param name="randomGenerator">随机数生成器</param>
protected PathGeneratorBase(IRandomGenerator randomGenerator)
{
_randomGenerator = randomGenerator ?? GuidRandomGenerator.Instance;
}
/// <summary>
/// </summary>
public static void Initialize(WPFXamlDefinition xamlDefinition)
{
ValidateInitialization();
lock (_lockObj)
{
ValidateInitialization();
_xamlDefinition = xamlDefinition;
_rnd = xamlDefinition.RandomGenerator;
string[] xamlFiles =
{
BuildPath("pagesource1.xaml"),
BuildPath("pagesource2.xaml")
};
string[] resourcesFiles =
{
BuildPath("arial.ttf"),
BuildPath("bee.wmv"),
BuildPath("Gone Fishing.bmp"),
BuildPath("small font.ttf")
};
string[] dllFiles =
{
BuildPath("TestRuntimeUntrusted.dll")
};
DefaultResourcesFiles = new List <string>(4);
DefaultXamlFiles = new List <string>(2);
DefaultDllFiles = new List <string>(3);
DefaultResourcesFiles.AddRange(resourcesFiles);
DefaultXamlFiles.AddRange(xamlFiles);
DefaultDllFiles.AddRange(dllFiles);
DefaultRandomGenerator.SetGlobalRandomGenerator(xamlDefinition.RandomGenerator);
//
// Create generators.
//
List <XmlGenerator> generators = new List <XmlGenerator>();
switch (_rnd.Next(5))
{
case 0:
// Includes everything except custom types, BitmapEffect, and LayoutTransform.
_generator = new XamlGenerator(BuildPath("RootTypes.xsd"));
break;
case 1:
// Includes everything except custom types, MediaElement, and BitmapEffect.
_generator = new XamlGenerator(BuildPath("RootTypes2.xsd"));
_shouldTestTransforms = true;
break;
case 2:
// Includes everything except custom types, flow types, MediaElement, and BitmapEffect.
_generator = new XamlGenerator(BuildPath("RootTypes3.xsd"));
_shouldTestTransforms = true;
break;
case 3:
// Includes everything except flow types, MediaElement, BitmapEffect, and LayoutTransform.
_generator = new XamlGenerator(BuildPath("RootTypes4.xsd"));
break;
case 4:
// Includes everything except custom types, flow types, MediaElement, and LayoutTransform.
_generator = new XamlGenerator(BuildPath("RootTypes5.xsd"));
_shouldTestBitmapEffects = true;
break;
}
_windowGenerator = new XamlGenerator(BuildPath("WindowTypes.xsd"));
_freezableGenerator = new XamlGenerator(BuildPath("RootFreezableTypes.xsd"));
_resourceGenerator = new XamlGenerator(BuildPath("ResourcesType.xsd"));
generators.Add(_generator);
generators.Add(_windowGenerator);
generators.Add(_freezableGenerator);
generators.Add(_resourceGenerator);
TextContentHelper textContentHelper = new TextContentHelper(_GenerateText);
ElementHelper elementHelper = new ElementHelper(_GenerateElement);
AttributeHelper attributeHelper1 = new AttributeHelper(_GenerateXmlLangValue);
AttributeHelper attributeHelper2 = new AttributeHelper(_GenerateNameValue);
AttributeHelper attributeHelper3 = new AttributeHelper(_GenerateAllowsTransparencyValue);
foreach (XmlGenerator generator in generators)
{
// Initialize XamlGenerator's random generator.
generator.Reset(_rnd.Next());
// Register helper for generating text content.
generator.RegisterTextHelper(textContentHelper);
// Register helper for generating elements so we can filter
// out stuff inside Templates.
generator.RegisterElementHelper(elementHelper);
// Register helpers for generating xml:lang, Name, and AllowsTransparency values.
generator.RegisterAttributeHelper(attributeHelper1, "lang");
generator.RegisterAttributeHelper(attributeHelper2, "Name");
generator.RegisterAttributeHelper(attributeHelper3, "AllowsTransparency");
}
_initialized = true;
}
}
public OneObjectGenerate(IRandomGenerator <T> generator)
{
_generator = generator;
}
/// <summary>
/// </summary>
public static void SetGlobalRandomGenerator(IRandomGenerator randomGenerator)
{
_randomGenerator = randomGenerator;
}
public SecureRandom()
: base(0)
{
this.generator = new DigestRandomGenerator(new Sha1Digest());
SetSeed(GetSeed(8));
}
public GameService(IRandomGenerator randomNumberGenerator)
{
this.randomNumberGenerator = randomNumberGenerator;
}
public SeedUnionExpression(List <IExpression> expressions, IRandomGenerator random) : base(expressions, random)
{
}
