private void ArcMapItemAdded(object item)
{
var newLayer = item as ILayer2;
if (newLayer != null)
{
AvailableFeatures.Add(new Feature(newLayer));
}
}
private void ArcMapItemDeleted(object item)
{
var featureToRemove = AvailableFeatures.FirstOrDefault(f => f.ESRILayer == item);
if (featureToRemove != null && featureToRemove.IsSelected)
{
featureToRemove.IsSelected = false;
PropertyChanged.Notify(() => SelectedFeature);
}
AvailableFeatures.Remove(featureToRemove);
}
public static int CreateMemeId(AvailableFeatures affectedFeature, int seed)
{
if (seed <= 0)
{
throw new Exception($"Incorrect seed = {seed} is to low.");
}
if (seed << 6 >> 6 != seed)
{
throw new Exception($"Incorrect seed = {seed} is to big.");
}
return((seed << 6) + (int)affectedFeature);
}
private void TestGenerateMeme(object sender, RoutedEventArgs e)
{
Random randomizer = new Random();
StringBuilder sb = new StringBuilder();
for (int i = 1; i < 10000; i++)
{
AvailableFeatures af = AvailableFeatures.HuntingEfficiency;
Meme newMeme = Meme.InventNewMeme(i, af);
sb.AppendFormat("{0}\t{1}\tHunting Efficiency\n", newMeme.Efficiency, newMeme.Price);
}
File.WriteAllText("c:\\temp\\memes.csv", sb.ToString());
}
public SucessStatistic(Meme meme, int goesAwayYear)
{
memeId = meme.MemeId;
affectedFeature = meme.AffectedFeature;
efficiency = meme.efficiency;
price = meme.price;
complexityCoefficient = meme.complexityCoefficient;
yearInvented = meme.yearInvented;
currentPopulation = meme.knownBy;
maxPopulation = meme.maxKnowBy;
maxPopulationYear = meme.maxKnownByYear;
totalPopulation = meme.totalKnowBy;
this.goesAwayYear = goesAwayYear;
}
public ToolParameterContainer GetToolParameterBasedOnSelectedFields()
{
IList <IToolParameter> toolParameter = new List <IToolParameter>();
foreach (var currentAvailableLayer in AvailableFeatures.Where(l => l.IsSelected))
{
foreach (var currentField in currentAvailableLayer.Fields.Where(f => f.IsSelected))
{
toolParameter.Add(new ToolParameter(currentField.FieldName));
}
}
return(new ToolParameterContainer(toolParameter));
}
public void EstablishLink(AbstractToolTemplate tool)
{
var featureLayer = AvailableFeatures.First(l => l.IsSelected && l.IsSuitableForMCDA).FeatureLayer;
var featureClass = featureLayer.FeatureClass;
var copiedFeatureClass = CopyFeatureClassIntoNewWorkspace(featureClass, _shadowWorkspace, tool + CreateTimeStamp());
var newFeatureLayer = new FeatureLayerClass {
Name = CreateLayerName(tool)
};
var feature = new Feature(copiedFeatureClass, newFeatureLayer);
_dictionaryOfLinks.Add(tool, feature);
PropertyChanged.Notify(() => LinkDictionary);
}
public static Meme InventNewMeme(int seed, AvailableFeatures memeAffectedFeature, List <Meme> memesAlreadyKnown = null)
{
Meme meme = new Meme(memeAffectedFeature, CreateMemeId(memeAffectedFeature, seed));
var randomizer = new Random(meme.MemeId);
meme.yearInvented = World.Year;
FeatureDescription featureDescription = WorldProperties.FeatureDescriptions[(int)memeAffectedFeature];
meme.keepDiary = randomizer.Chance(WorldProperties.ChancesThatMemeWillWriteALog);
meme.efficiency = -1;
meme.price = -1;
if (featureDescription.MemeEfficiencyMean > 1 && (featureDescription.range == FeatureRange.ZeroToOne || featureDescription.range == FeatureRange.MinusOneToPlusOne))
{
meme.efficiency = 1;
}
else if (featureDescription.MemeEfficiencyMean <= -1 && featureDescription.range == FeatureRange.MinusOneToPlusOne)
{
meme.efficiency = -1;
}
else
{
do
{
meme.efficiency = randomizer.NormalRandom(featureDescription.MemeEfficiencyMean, featureDescription.MemeEfficiencyStdDev);
if (meme.efficiency == 0)
{
Console.WriteLine($"meme.efficiency == 0");
}
}while (meme.efficiency < featureDescription.LowerRange || (meme.efficiency > featureDescription.UpperRange)); // А что, все мымы теперь 0-1? Может у нас специальный мем снижающий какое-то качество, почему бы и нет, собственно? Пусть отбор решает. Заодно посмотрим что он там нарешать сможет.
}
meme.complexityCoefficient = Math.Pow(2, (meme.efficiency - featureDescription.MemeEfficiencyMean) / featureDescription.MemeEfficiencyStdDev); // Зачем вообще complexityCoefficient считать внутри цикла?
while (meme.price < 0)
{
var pedestalPrice = featureDescription.MemePricePedestal;
var efficiencyPrice = Math.Abs(meme.efficiency) * featureDescription.MemePriceEfficiencyRatio;
var randomPricePart = randomizer.NormalRandom(featureDescription.MemePriceRandomMean, featureDescription.MemePriceRandomStdDev);
var complexityMultiplier = Math.Pow(meme.ComplexityCoefficient, WorldProperties.MemeCostComplexityPriceCoefficient);
meme.price = (pedestalPrice + efficiencyPrice + randomPricePart) * complexityMultiplier;
}
meme.Report(string.Format("Meme teaches how {3}. It affects: {0}; Efficiency: {1:f5}; It takes {2:f2} memory.", memeAffectedFeature.GetDescription(), meme.Efficiency, meme.Price, meme.ActionDescription)); // Логер, конечно, можно не переделывать, потому что мемы создаются шибко редко.
return(meme);
}
private IList <Field> GetListOfFieldsFromToolParameter <T>(IEnumerable <T> toolParameter) where T : IToolParameter
{
IList <Field> listOfFields = new List <Field>();
foreach (var currentToolParameter in toolParameter)
{
foreach (var currentAvailableLayer in AvailableFeatures.Where(l => l.IsSelected))
{
var parameter = currentToolParameter;
foreach (var currentField in currentAvailableLayer.Fields.Where(f => f.FieldName.Equals(parameter.ColumnName)))
{
listOfFields.Add(currentField);
}
}
}
return(listOfFields);
}
public double GoHunting(AvailableFeatures huntingEfficiencyFeature)
{
double sumHuntingPowers = 0;
double cooperationCoefficient = 0;
int numHunters = 0;
foreach (Tribesman man in members)
{
var chance = man.GetFeature(AvailableFeatures.LikelyhoodOfNotBeingAFreeRider);
if (randomizer.Chance(chance))
{
double huntingEfforts = man.GoHunting(huntingEfficiencyFeature);
if (huntingEfforts > 0)
{
sumHuntingPowers += huntingEfforts;
cooperationCoefficient += man.GetFeature(AvailableFeatures.CooperationEfficiency);
numHunters++;
}
}
else
{
man.SkipHunting();
}
}
if (members.Count > 0)
{
StatisticsCollector.ReportAverageEvent(TribeName, "Percentage of hunters", (double)numHunters / members.Count);
}
if (numHunters == 0)
{
return(0);
}
cooperationCoefficient /= numHunters;
StatisticsCollector.ReportAverageEvent(TribeName, "Average hunting efforts", sumHuntingPowers * cooperationCoefficient);
StatisticsCollector.ReportSumEvent(TribeName, "Total hunting efforts", sumHuntingPowers * cooperationCoefficient);
return(sumHuntingPowers * cooperationCoefficient);
}
private static void HuntAndShare(AvailableFeatures huntingEfficiencyFeature)
{
double totalEnvironmentResources = 0;
if (huntingEfficiencyFeature == AvailableFeatures.HuntingEfficiency)
{
totalEnvironmentResources = RandomizeResources(
WorldProperties.ResourcesAvailableFromEnvironmentOnEveryStep,
WorldProperties.ResourcesAvailableFromEnvironmentOnEveryStepStdDev,
WorldProperties.ResourcesAvailableFromEnvironmentOnEveryStepDeviationLimit);
if (WorldProperties.ResourcesABReplacementPeriod > 0)
{
totalEnvironmentResources *=
((1 + Math.Cos(Year * 2 * Math.PI / WorldProperties.ResourcesABReplacementPeriod)) / 2 *
(WorldProperties.ResourcesAvailableFromEnvironmentOnEveryStep - WorldProperties.ResourcesAAvailableFromEnvironmentMinimum)
+ WorldProperties.ResourcesAAvailableFromEnvironmentMinimum) / WorldProperties.ResourcesAvailableFromEnvironmentOnEveryStep;
}
}
else
{
totalEnvironmentResources = RandomizeResources(
WorldProperties.ResourcesBAvailableFromEnvironmentOnEveryStep,
WorldProperties.ResourcesBAvailableFromEnvironmentOnEveryStepStdDev,
WorldProperties.ResourcesBAvailableFromEnvironmentOnEveryStepDeviationLimit);
if (WorldProperties.ResourcesABReplacementPeriod > 0)
{
totalEnvironmentResources *=
((1 - Math.Cos(Year * 2 * Math.PI / WorldProperties.ResourcesABReplacementPeriod)) / 2 *
(WorldProperties.ResourcesBAvailableFromEnvironmentOnEveryStep - WorldProperties.ResourcesBAvailableFromEnvironmentMinimum)
+ WorldProperties.ResourcesBAvailableFromEnvironmentMinimum) / WorldProperties.ResourcesBAvailableFromEnvironmentOnEveryStep;
}
}
if (totalEnvironmentResources == 0)
{
return;
}
ConcurrentDictionary <Tribe, double> tribeHuntingEfforts = new ConcurrentDictionary <Tribe, double>(); // Тут порядок всё равно не важен, используется только сумма, поэтому тут ConcurrentDictionary не трогаем
World.tribes.Parallel((tribe) => { tribeHuntingEfforts.TryAdd(tribe, tribe.GoHunting(huntingEfficiencyFeature)); });
double totalHuntingEffort = 0;
foreach (Tribe t in tribes)
{
totalHuntingEffort += tribeHuntingEfforts[t];
}
Dictionary <Tribe, double> resourcesRecievedByTribes = new Dictionary <Tribe, double>(); // Тут запись идёт в основном потоке, а из тредов только чтение. Чтение не может нарушить целостность, так что нефиг тут ConcurrentDictionary плодить.
if (totalHuntingEffort <= totalEnvironmentResources || totalEnvironmentResources < 0)
{
foreach (Tribe t in tribes)
{
resourcesRecievedByTribes.Add(t, tribeHuntingEfforts[t]);
}
}
else
{
var resourcePerHuntingEffort = totalEnvironmentResources / totalHuntingEffort; // Деление - медленная операция. Это, конечно, копейки, но зачем их в пустую тратить.
foreach (Tribe t in tribes)
{
resourcesRecievedByTribes.Add(t, resourcePerHuntingEffort * tribeHuntingEfforts[t]);
}
}
World.tribes.Parallel((tribe) => { tribe.ReceiveAndShareResource(resourcesRecievedByTribes[tribe]); });
}
public static string GenerateActionDescription(AvailableFeatures af, bool negate = false)
{
List <string> options = null;
switch (af)
{
case AvailableFeatures.CooperationEfficiency:
options = CooperationEfficiencyActions;
break;
case AvailableFeatures.FreeRiderDeterminationEfficiency:
options = FreeRiderDeterminationEfficiencyActions;
break;
case AvailableFeatures.FreeRiderPunishmentLikelyhood:
options = FreeRiderPunishmentLikelyhoodActions;
break;
case AvailableFeatures.HuntingEfficiency:
options = HuntingEfficiencyActions;
break;
case AvailableFeatures.LikelyhoodOfNotBeingAFreeRider:
options = LikelyhoodOfNotBeingAFreeRiderActions;
break;
case AvailableFeatures.StudyEfficiency:
options = StudyEfficiencyActions;
break;
case AvailableFeatures.StudyLikelyhood:
options = StudyLikelyhoodActions;
break;
case AvailableFeatures.TeachingEfficiency:
options = TeachingEfficiencyActions;
break;
case AvailableFeatures.TeachingLikelyhood:
options = TeachingLikelyhoodActions;
break;
case AvailableFeatures.TrickEfficiency:
options = TrickEfficiencyActions;
break;
case AvailableFeatures.TrickLikelyhood:
options = TrickLikelyhoodActions;
break;
case AvailableFeatures.UselessActionsLikelihood:
options = uselessActions;
break;
case AvailableFeatures.AgeingRate:
options = AgeingRateActions;
break;
}
if (options == null)
{
return("");
}
string retval = null;
lock (_lock)
retval = options[random.Next(options.Count)];
if (negate)
{
if (retval.IndexOf("not") > -1)
{
retval = retval.Replace("not ", "");
}
else
{
Regex regex = new Regex(Regex.Escape("to"));
retval = regex.Replace(retval, "not to", 1);
}
}
return(retval);
}
public static double GetFeature(this double[] genes, AvailableFeatures feature)
{
return(genes[(int)feature]);
}
public static double SetFeature(this double[] genes, AvailableFeatures feature, double value)
{
return(genes[(int)feature] = value);
}
/// <summary>
/// Returns the field of the OID for the selected feature. However, it is possible that no feature is selected
/// or that no OID exists or both. In this the methods returns null.
/// </summary>
/// <returns></returns>
private Field GetOIDFieldFromSelectedFeature()
{
var selectedFeature = AvailableFeatures.FirstOrDefault(f => f.IsSelected);
return(selectedFeature == null ? null : selectedFeature.Fields.FirstOrDefault(f => f.IsOID));
}
public double this[AvailableFeatures feature] {
get { return(resultingSet[(int)feature]); }
}
public static Meme InventNewMeme(Random randomizer, AvailableFeatures memeAffectedFeature, List <Meme> memesAlreadyKnown = null)
{
var memesTimesMaxCount = WorldProperties.MemesTimesMaxCount > 0 ? (int)WorldProperties.MemesTimesMaxCount : MEMES_TYPES_MAX_COUNT;
return(InventNewMeme(randomizer.Next(memesTimesMaxCount), memeAffectedFeature, memesAlreadyKnown));
}
private Meme(AvailableFeatures affectedFeature, int memeId)
{
this.AffectedFeature = affectedFeature;
MemeId = memeId;
}
public static void ParseMemeId(int memeId, out AvailableFeatures affectedFeature, out int seed)
{
affectedFeature = (AvailableFeatures)(memeId & ((1 << 7) - 1));
seed = memeId >> 6;
}
