public FromDistributionAttribute(Type type, params object[] parameters)
{
if (parameters.Length > 2)
{
throw new ArgumentException($"{type} can't have wrong arguments.");
}
Distribution = (IContinousDistribution)Activator.CreateInstance(type, parameters);
}
public FromDistributionAttribute(Type distribution, params object[] values)
{
if (values.Length > 2)
{
throw new ArgumentException("NormalDistribution must Contain 2 arguments");
}
Distribution = (IContinousDistribution)Activator.CreateInstance(distribution, values);
}
public FromDistribution(Type type, params object[] args)
{
try {
Distribution = (IContinousDistribution)Activator.CreateInstance(type, args);
}
catch (Exception) {
throw new ArgumentException(type.Name);
}
}
public FromDistribution(Type type, params object[] args)
{
try {
Distribution = (IContinousDistribution)Activator.CreateInstance(type, args);
}
catch (MissingMethodException) {
throw new ArgumentException($"Ctor with parameters {string.Join(", ", args)} for type {type} not found");
}
}
public Generator <T> Set(IContinousDistribution distribution)
{
if (_properties.ContainsKey(_selectedName))
{
_properties[_selectedName] = distribution;
}
return(new Generator <T>(_properties));
}
private void AssertPropertyFilledWithDistribution(double actualValue, IContinousDistribution distribution)
{
var random = new Random(seed);
var sequenceStart = new[] { distribution.Generate(random), distribution.Generate(random), distribution.Generate(random), distribution.Generate(random), distribution.Generate(random) };
random = new Random(seed);
random.NextDouble();
var sequence = sequenceStart.Concat(new[] { distribution.Generate(random), distribution.Generate(random), distribution.Generate(random), distribution.Generate(random), distribution.Generate(random) });
Assert.That(sequence, Does.Contain(actualValue));
}
public Generator <TParameter> Set(IContinousDistribution continousDistribution)
{
if (Generator <TParameter> .dictionaryDistribution.ContainsKey(SetProperty))
{
Generator <TParameter> .dictionaryDistribution[SetProperty] = continousDistribution;
}
else
{
throw new ArgumentException();
}
return(Generator);
}
public Generator <T> Set(IContinousDistribution distribution)
{
var properties = typeof(T).GetProperties();
for (int i = 0; i < properties.Length; i++)
{
if (properties[i].Name == propertyHandler)
{
DictOfProperties[properties[i]] = distribution;
break;
}
}
return(this);
}
public static Generator <T> Set <T>(this Config <T> config, IContinousDistribution distribution) where T : new()
{
foreach (var property in config.propertyNames)
{
if (config.generator.distributions.ContainsKey(property))
{
config.generator.distributions[property] = distribution;
}
else
{
config.generator.distributions.Add(property, distribution);
}
}
return(config.generator);
}
public static Generator <T> Set <T>(
this Tuple <Generator <T>, PropertyInfo> pair,
IContinousDistribution distribution)
where T : new()
{
PropertyInfo key = null;
foreach (var e in pair.Item1.Properties)
{
if (e.Key.Name == pair.Item2.Name)
{
key = e.Key;
}
}
pair.Item1.Properties[key] = distribution;
return(pair.Item1);
}
public Generator()
{
_properties = new Dictionary <string, IContinousDistribution>();
foreach (var propertyInfo in typeof(T).GetProperties())
{
var attr = propertyInfo.GetCustomAttributes <FromDistribution>().SingleOrDefault();
if (attr == null)
{
_properties.Add(propertyInfo.Name, null);
}
else
{
IContinousDistribution instance = null;
if (attr.Type == typeof(NormalDistribution))
{
if (attr.Parameters.Length != 0 && attr.Parameters.Length != 2)
{
throw new ArgumentException("NormalDistribution");
}
instance = attr.Parameters.Length == 0
? (IContinousDistribution)Activator.CreateInstance(attr.Type)
: (IContinousDistribution)Activator.CreateInstance(attr.Type,
new object[] { attr.Parameters[0], attr.Parameters[1] });
}
else if (attr.Type == typeof(ExponentialDistribution))
{
if (attr.Parameters.Length != 1)
{
throw new ArgumentException("ExponentialDistribution");
}
instance = (IContinousDistribution)Activator.CreateInstance(attr.Type,
new object[] { attr.Parameters[0] });
}
else
{
throw new ArgumentException();
}
_properties.Add(propertyInfo.Name, instance);
}
}
}
public T Generate(Random rnd)
{
T e = new T();
foreach (var prop in properties)
{
var curAttr = (FromDistributionAttribute)prop.GetCustomAttribute(typeof(FromDistributionAttribute));
IContinousDistribution rndDistrib = null;
if (Distributions.ContainsKey(prop))
{
rndDistrib = Distributions[prop];
}
else if (curAttr != null)
{
rndDistrib = curAttr.Distribution;
}
else
{
continue;
}
prop.SetValue(e, rndDistrib.Generate(rnd));
}
return(e);
}
public static Generator <T> Set <T>(this CustomGenerator <T> customGenerator, IContinousDistribution newDistribution) where T : new()
{
Generator <T> .Distributions[customGenerator.PointedProperty] = newDistribution;
return(customGenerator.Generator);
}
/// <summary>
/// Добавляет свойство
/// объекта в словарь
/// генератора
/// </summary>
/// <param name="distribution">
/// Распределение
/// </param>
/// <returns>
/// Генератор случайных чисел
/// данного временного объекта
/// </returns>
public Generator <T> Set(IContinousDistribution distribution)
{
generator.Dictionary.Add(this.property, distribution);
return(generator);
}
public Generator <T> Set(IContinousDistribution distribution)
{
mainGenerator.customizableProperties[propertyName] = distribution;
return(mainGenerator);
}
public Generator <T> Set(IContinousDistribution distribution)
{
_parent._propertiesToDistribution[_propertyName] = distribution;
_parent._needToRecompileBuildingFunc = true;
return(_parent);
}
public Generator <T> Set(IContinousDistribution distribution)
{
Distribution = distribution;
return(Generator);
}
public Generator <T> Set(IContinousDistribution distribution)
{
_currentGenerator.dynamicDictionary.Add(_classProperty, distribution);
return(_currentGenerator);
}
