//Learning Accessory functions
private static ConsensusResults ConsensusLearning(SimParams par, Population pop,
List <int>[] tutors, List <int> learners)
{
//Create a consensus based on songs from several males
List <int>[] ConsensusSongs = new List <int> [learners.Count];
List <int>[] AddSyls = new List <int> [learners.Count];
List <int>[] AllSongs;
List <int> CollapsedSongs;
float Conform;
for (int i = 0; i < learners.Count; i++)
{
ConsensusSongs[i] = new List <int> {
};
AddSyls[i] = new List <int> {
};
AllSongs = ListeningTest(par, pop, tutors[i].ToArray(), par.ListeningThreshold);
CollapsedSongs = AllSongs.SelectMany(x => x).ToList();
ConsensusSongs[i] = CollapsedSongs.Distinct().ToList();
for (int j = 0; j < ConsensusSongs[i].Count(); j++)
{
Conform = ConsensusCalc(par, ConsensusSongs[i][j], CollapsedSongs);
if (par.NextFloat() < Conform)
{
AddSyls[i].Add(ConsensusSongs[i][j]);
}
}
}
ConsensusResults Returnable = new ConsensusResults(AddSyls, ConsensusSongs);
return(Returnable);
}
public static Population ObliqueLearning(SimParams par, Population pop,
int[] vacant, List <int> notVacant)
{
//Get Learners and set up for each learning style
List <int> Learners = GetLearners(par, pop, notVacant);
List <int>[] AddSyls;
List <int>[] LoseSyls;
if (par.Consensus)
{
List <int>[] Tutors = ChooseMultipleTutors(par, pop, Learners,
notVacant, par.NumTutorConsensusStrategy);
var Results = ConsensusLearning(par, pop, Tutors, Learners);
AddSyls = Results.AddSyls;
LoseSyls = Results.ConsensusSongs;
}
else //Add&|Forget Learning
{
int[] Tutors = ChooseTutors(par, pop, Learners, notVacant);
AddSyls = ListeningTest(par, pop, Tutors, par.ListeningThreshold);
LoseSyls = AddSyls;
}
//Add and/or remove syllables as needed and update song-related traits
if (par.Add)
{
AddSyllables(par, pop, Learners, AddSyls);
}
if (par.Forget)
{
ForgetSyllables(par, pop, Learners, LoseSyls);
}
UpdateSongTraits(par, pop, Learners);
return(pop);
}
private static List <int> TestLearningThreshold(SimParams par, Population pop,
List <int> notVacant)
{
/*Get birds with a threshold below the age keepign in mind
* the vertical learning threshold*/
float ModifiedThresh;
List <int> Learners = new List <int> {
};
for (int i = 0; i < notVacant.Count; i++)
{
ModifiedThresh = pop.LearningThreshold[notVacant[i]] >= 1?
pop.LearningThreshold[notVacant[i]]:
(pop.LearningThreshold[notVacant[i]] - par.VerticalLearningCutOff) / (1 - par.VerticalLearningCutOff);
if (pop.Age[notVacant[i]] + 1 <= ModifiedThresh)//full learn to learn
{
Learners.Add(notVacant[i]);
}
else if (pop.Age[notVacant[i]] < ModifiedThresh) //Chance to learn during partical year
{
if (par.NextFloat() < ModifiedThresh - pop.Age[notVacant[i]])
{
Learners.Add(notVacant[i]);
}
}
}
return(Learners);
}
private static float[] CalculateSocialBonus(SimParams par, Population pop,
List <int> usableMales)
{
float[] SocialBonus = new float[usableMales.Count];
if (par.SocialPreference != 0)
{
float[] Soc = new float[usableMales.Count];
for (int i = 0; i < usableMales.Count; i++)
{
Soc[i] = pop.Bred[usableMales[i]];
}
float Worst = Soc.Min();
float Best = Soc.Max();
if (Worst == Best)
{
SocialBonus = Enumerable.Repeat(par.SocialPreference, usableMales.Count).ToArray();
}
else
{
float Fraction = 1f / (Best - Worst);
for (int i = 0; i < usableMales.Count; i++)
{
SocialBonus[i] = ((Soc[i] - Worst) * Fraction) * par.SocialPreference;
}
}
}
else
{
SocialBonus = Enumerable.Repeat(0f, usableMales.Count).ToArray();
}
return(SocialBonus);
}
//Misc
public static Population OverLearn(SimParams par, Population pop,
int[] vacant, List <int> notVacant)
{
//Get learners and tutors
List <int> Learners = vacant.ToList();
List <int>[] Tutors = ChooseMultipleTutors(par, pop, Learners, notVacant, par.NumTutorOverLearn);
List <int>[] TutorSyls = new List <int> [Learners.Count];
//Create combined song with all sylls
List <int>[] AllSongs;
List <int> CollapsedSongs;
for (int i = 0; i < Learners.Count; i++)
{
AllSongs = ListeningTest(par, pop, Tutors[i].ToArray(), par.ListeningThreshold);
CollapsedSongs = AllSongs.SelectMany(x => x).ToList();
TutorSyls[i] = CollapsedSongs.Distinct().ToList();
}
//Add Syls and update song traits
AddSyllables(par, pop, Learners, TutorSyls);
UpdateSongTraits(par, pop, Learners);
return(pop);
}
private static int[] RandomDeath(SimParams par, Population pop)
{
float[] PickChance = LearningPenalty(par, pop.LearningThreshold);
int numLostBirds = (int)Math.Floor(par.NumBirds * par.PercentDeath);
int[] LostBirds = par.RandomSampleUnequal(PickChance, numLostBirds, false);
return(LostBirds);
}
//Birth
private static int[] ChooseMaleFathers(SimParams par, Population pop,
int[] vacant, List <int> notVacant)
{
/*Picks fathers to sire chicks into vacancies,
* Uses only living males.
* It is likely for high quality males to sire multiple
* offspring in one sim step for both local and global scopes*/
//Remove songless birds from notVacant, and mark all not in that list as unavailable
HashSet <int> PotentialFathersTemp = new HashSet <int>(notVacant.Where(x => pop.SyllableRepertoire[x] > 0));
HashSet <int> Unavailable = new HashSet <int>(Enumerable.Range(0, par.NumBirds));
Unavailable.ExceptWith(PotentialFathersTemp);
//Get the probabilities
List <int> PotentialFathers = PotentialFathersTemp.ToList();
float[] Probs = ReproductiveProbability(par, pop, PotentialFathers);
//pick fathers
int[] Fathers = new int[vacant.Length];
if (par.LocalBreeding)
{
float[] Probability = Enumerable.Repeat(0f, par.NumBirds).ToArray();
for (int i = 0; i < PotentialFathers.Count; i++)
{
Probability[PotentialFathers[i]] = Probs[i];
}
for (int i = 0; i < Fathers.Length; i++)
{
Fathers[i] = Locations.GetLocalBirds(par, pop, vacant[i],
Unavailable, probs: Probability)[0];
}
}
else
{
//float[] PotenProbs = new float[PotentialFathers.Count];
int[] FatherIndex;
//for(int i=0;i<PotenProbs.Length;i++){
// PotenProbs[i] = Probability[PotentialFathers[i]];
//}
FatherIndex = par.RandomSampleUnequal(Probs, vacant.Length, true);
for (int i = 0; i < Fathers.Length; i++)
{
Fathers[i] = PotentialFathers[FatherIndex[i]];
}
}
int[] lol = new int[Fathers.Length];
for (int i = 0; i < Fathers.Length; i++)
{
lol[i] = pop.SyllableRepertoire[Fathers[i]];
}
return(Fathers);
}
//Constructor
public Songs(SimParams par)
{
Match = new float[par.NumBirds];
MaleSongs = new List <int> [par.NumBirds];
FemaleSongs = new List <int> [par.NumBirds];
if (par.MatchPreference == 0 && !par.SaveMatch)
{
for (int i = 0; i < par.NumBirds; i++)
{
MaleSongs[i] = GenerateNovelSong(par);
}
}
else //Matching context
{
FemaleSongs = GenerateFemaleSongs(par);
if (par.MaleDialects == "Same")
{
for (int i = 0; i < MaleSongs.Length; i++)
{
MaleSongs[i] = FemaleSongs[i].ToList();
}
}
else
{
for (int i = 0; i < par.NumBirds; i++)
{
MaleSongs[i] = GenerateNovelSong(par);
}
if (par.MaleDialects == "Similar" && par.NumDialects > 1)
{
MaleSongs = EstablishDialects(par, MaleSongs);
}
}
if (par.ChooseMate && par.MaleDialects != "Same")
{
var Assign = AssignFemale(par, MaleSongs, FemaleSongs);
List <int>[] NewMaleSong = new List <int> [par.NumBirds];
List <int>[] NewFemaleSong = new List <int> [par.NumBirds];
for (int i = 0; i < par.NumBirds; i++)
{
NewMaleSong[i] = MaleSongs[Assign.MaleOrder[i]];
NewFemaleSong[i] = FemaleSongs[Assign.FemaleOrder[i]];
}
MaleSongs = NewMaleSong;
FemaleSongs = NewFemaleSong;
Match = Assign.Match;
}
else
{
for (int i = 0; i < par.NumBirds; i++)
{
Match[i] = Songs.GetMatch(par, MaleSongs[i], FemaleSongs[i]);
}
}
}
}
//Getting tutors, the original runs faster, but cannot get more than one tutor
private static int[] ChooseTutors(SimParams par, Population pop,
List <int> learners, List <int> notVacant)
{
//Picks tutos that are alive, not chicks, and not songless,
//Males can tutor multiple learners
/*remove chicks and songless birds + any Misc, mark all excluded
* birds as unavailable*/
HashSet <int> PotentialTutorsTemp = new HashSet <int>(notVacant.Where(x => pop.Age[x] > 0));
PotentialTutorsTemp.ExceptWith(PotentialTutorsTemp.Where(x => pop.SyllableRepertoire[x] == 0).ToArray());
//pick Tutors
int[] Tutors = new int[learners.Count];
if (par.LocalTutor)
{
//Set up unavailable for local testing
HashSet <int> Unavailable = new HashSet <int>(Enumerable.Range(0, par.NumBirds));
Unavailable.ExceptWith(PotentialTutorsTemp);
for (int i = 0; i < learners.Count; i++)
{
if (par.SocialCues)
{
Tutors[i] = Locations.GetLocalBirds(par, pop, learners[i], Unavailable, 1, pop.Bred)[0];
}
else
{
Tutors[i] = Locations.GetLocalBirds(par, pop, learners[i], Unavailable)[0];
}
}
}
else //drawn individually so no learner is his own tutor
{
List <int> PotentialTutors;
for (int i = 0; i < learners.Count; i++)
{
PotentialTutors = PotentialTutorsTemp.ToList();
PotentialTutors.Remove(learners[i]);
if (par.SocialCues)
{
float[] TutorProbs = new float[PotentialTutors.Count];
for (int j = 0; j < TutorProbs.Length; j++)
{
TutorProbs[j] = pop.Bred[PotentialTutors[j]];
}
Tutors[i] = PotentialTutors[par.RandomSampleUnequal(TutorProbs, 1)[0]];
}
else
{
Tutors[i] = PotentialTutors[par.RandomSampleEqualReplace(PotentialTutors, 1)[0]];
}
}
}
return(Tutors);
}
private static List <int>[] ChooseMultipleTutors(SimParams par, Population pop,
List <int> learners, List <int> notVacant, int numTutors)
{
/*remove chicks and songless birds + any Misc, mark all excluded
* birds as unavailable*/
HashSet <int> PotentialTutorsTemp = new HashSet <int>(notVacant.Where(x => pop.Age[x] > 0));
PotentialTutorsTemp.ExceptWith(PotentialTutorsTemp.Where(x => pop.SyllableRepertoire[x] == 0).ToArray());
List <int>[] Tutors = new List <int> [learners.Count];
if (par.LocalTutor)
{
HashSet <int> Unavailable = new HashSet <int>(Enumerable.Range(0, par.NumBirds));
Unavailable.ExceptWith(PotentialTutorsTemp);
for (int i = 0; i < learners.Count; i++)
{
if (par.SocialCues)
{
Tutors[i] = Locations.GetLocalBirds(par, pop, learners[i], Unavailable, numTutors, pop.Bred).ToList();
}
else
{
Tutors[i] = Locations.GetLocalBirds(par, pop, learners[i], Unavailable, numTutors).ToList();
}
}
}
else
{
List <int> PotentialTutors;
for (int i = 0; i < learners.Count; i++)
{
PotentialTutors = PotentialTutorsTemp.ToList();
PotentialTutors.Remove(learners[i]);
if (par.SocialCues)
{
float[] TutorProbs = new float[PotentialTutors.Count];
for (int j = 0; j < TutorProbs.Length; j++)
{
TutorProbs[j] = pop.Bred[PotentialTutors[j]];
}
int[] ChosenIndex = par.RandomSampleUnequal(TutorProbs, numTutors);
for (int j = 0; j < numTutors; j++)
{
ChosenIndex[j] = PotentialTutors[ChosenIndex[j]];
}
Tutors[i] = ChosenIndex.ToList();
}
else
{
Tutors[i] = par.RandomSampleEqualNoReplace(PotentialTutors, numTutors).ToList();
}
}
}
return(Tutors);
}
private static List <int> GetLearners(SimParams par, Population pop, List <int> notVacant)
{
List <int> Capable = TestLearningThreshold(par, pop, notVacant);
Capable = CheckEncounter(par, Capable);
if (Capable.Count == 0)
{
Console.WriteLine("Warning: There were no learners.");
} //throw new Exception("There were no learners.");}
return(Capable);
}
private static List <int> CheckEncounter(SimParams par, List <int> capable)
{
for (int i = capable.Count - 1; i >= 0; i--)
{
if (par.NextFloat() > par.EncounterSuccess)
{
capable.RemoveAt(i);
}
}
return(capable);
}
private static Population UpdateSongTraits(SimParams par, Population pop, List <int> learners)
{
for (int i = 0; i < learners.Count; i++)
{
pop.SyllableRepertoire[learners[i]] = pop.MaleSong[learners[i]].Count;
if (par.MatchPreference != 0 || par.SaveMatch)
{
pop.Match[learners[i]] = Songs.GetMatch(par, pop.MaleSong[learners[i]], pop.FemaleSong[learners[i]]);
}
}
return(pop);
}
/*Functions for decideing how birds learn and
* allowing them to do so*/
//Main process
public static List <int> CoreLearningProcess(SimParams par, Population pop,
int learner, List <int> learnerSong, List <int> tutorSong)
{
//Copy Tutor Syllables
List <float> Rolls = new List <float> {
};
float AccRoll;
for (int i = 0; i < tutorSong.Count; i++)
{
AccRoll = par.NextFloat();
if (AccRoll < pop.Accuracy[learner])//Correct
{
learnerSong.Add(tutorSong[i]);
}
else
{
Rolls.Add(AccRoll);
}
}
//Innovation
if (Rolls.Count > 0)
{
int Innovation = 0;
float InventThresh = 1 - ((1 - pop.Accuracy[learner]) * pop.ChanceInvent[learner]);
for (int i = 0; i < Rolls.Count; i++)
{
if (Rolls[i] >= InventThresh)
{
Innovation += 1;
}
}
if (Innovation > 0)
{
int[] NewSyls;
HashSet <int> AvailableSyllables = new HashSet <int>(par.AllSyls);
AvailableSyllables.ExceptWith(Enumerable.Concat(learnerSong, tutorSong));
if (Innovation >= AvailableSyllables.Count)//Not enough syls for sampling
{
NewSyls = AvailableSyllables.ToArray();
}
else // Enough syls for sampling
{
NewSyls = par.RandomSampleEqualNoReplace(AvailableSyllables.ToList(), Innovation);
}
learnerSong.AddRange(NewSyls);
} //Otherwise no innovation occured
} //Otherwise no mistakes were made
return(learnerSong);
}
//Constructor
public Population(SimParams par)
{
//Get variables dependant on population size (Age, Survival Stats, and Locality)
Age = Ages.InitialAgeDistribution(par);
if (par.AgeDeath)
{
SurvivalChance = new List <float> {
par.ChickSurvival
};
SurvivalChance.AddRange(Enumerable.Repeat(par.InitialSurvival, par.MaxAge));
SurvivalStore = SurvivalChance[1];
}
if (par.LocalBreeding || par.LocalTutor)
{
Local = Locations.FinalDirections(par);
}
//Get Songs and song data
Songs SongData = new Songs(par);
MaleSong = SongData.MaleSongs;
FemaleSong = SongData.FemaleSongs;
Match = SongData.Match;
SyllableRepertoire = new int[par.NumBirds];
for (int i = 0; i < par.NumBirds; i++)
{
SyllableRepertoire[i] = MaleSong[i].Count;
}
if (par.SaveNames)
{
FatherName = Enumerable.Repeat("NA", par.NumBirds).ToArray();
Name = new string[par.NumBirds];
for (int i = 0; i < par.NumBirds; i++)
{
Name[i] = System.Guid.NewGuid().ToString();
}
}
Bred = Enumerable.Repeat(.1f, par.NumBirds).ToArray();
//Set up distributions for noisy inheritence as needed and fill out arrays
Accuracy = InitialDistributions(par, par.InheritedAccuracyNoise, par.InitialAccuracy,
par.MaxAccuracy, par.MinAccuracy);
LearningThreshold = InitialDistributions(par, par.InheritedLearningThresholdNoise, par.InitialLearningThreshold,
par.MaxLearningThreshold, par.MinLearningThreshold);
ChanceInvent = InitialDistributions(par, par.InheritedChancetoInventNoise, par.InitialChancetoInvent,
par.MaxChancetoInvent, par.MinChancetoInvent);
ChanceForget = InitialDistributions(par, par.InheritedChancetoForgetNoise, par.InitialChancetoForget,
par.MaxChancetoForget, par.MinChancetoForget);
}
private static List <int> DropSyllables(SimParams par, List <int> song,
List <int> droppableSyls, float chanceForget)
{
//Remove syllables not heard from tutor based on ChanceForget
for (int i = 0; i < droppableSyls.Count; i++)
{
if (par.NextFloat() < chanceForget)
{
song.Remove(droppableSyls[i]);
}
}
return(song);
}
private static void CheckStatValue(SimParams par, string type, float stat)
{
if (type == "Learning")
{
if (stat > par.MaxLearningThreshold || stat < par.MinLearningThreshold)
{
throw new System.ArgumentException("Chosen invader stat was outside the boundaries for Learning Threshold.");
}
if (par.InheritedLearningThresholdNoise != 0)
{
Console.WriteLine("Warning: Learning Inheritance noise not set to 0!");
}
}
else if (type == "Accuracy")
{
if (stat > par.MaxAccuracy || stat < par.MinAccuracy)
{
throw new System.ArgumentException("Chosen invader stat was outside the boundaries for Accuracy.");
}
if (par.InheritedAccuracyNoise != 0)
{
Console.WriteLine("Warning: Accuracy Inheritance noise not set to 0!");
}
}
else if (type == "Forget")
{
if (stat > par.MaxChancetoForget || stat < par.MinChancetoForget)
{
throw new System.ArgumentException("Chosen invader stat was outside the boundaries for Chance to Forget.");
}
if (par.InheritedChancetoForgetNoise != 0)
{
Console.WriteLine("Warning: Forget Inheritance noise not set to 0!");
}
}
else if (type == "Invent")
{
if (stat > par.MaxChancetoInvent || stat < par.MinChancetoInvent)
{
throw new System.ArgumentException("Chosen invader stat was outside the boundaries for Chance to Invent.");
}
if (par.InheritedChancetoInventNoise != 0)
{
Console.WriteLine("Warning: Invent Inheritance noise not set to 0!");
}
}
else
{
throw new System.ArgumentException("Type can only take the following values: Learning, Accuracy, Forget, or Invent.");
}
}
private static Population ForgetSyllables(SimParams par, Population pop,
List <int> learners, List <int>[] tutorSyls)
{
//Forget unheard Syllables
List <int> Lose;
for (int i = 0; i < learners.Count; i++)
{
Lose = pop.MaleSong[learners[i]].Except(tutorSyls[i]).ToList();
pop.MaleSong[learners[i]] = DropSyllables(par, pop.MaleSong[learners[i]],
Lose, pop.ChanceForget[i]);
}
return(pop);
}
//Top Level Organizers
public static List <int> VerticalLearning(SimParams par, Population pop,
int fatherInd, int chickInd)
{
List <int> NewSong = new List <int> {
};
if (pop.LearningThreshold[chickInd] < par.VerticalLearningCutOff)
{
return(NewSong);
}
List <int> FatherSong = ListeningTest(par, pop, new int[] { fatherInd }, par.FatherListeningThreshold)[0];
List <int> ChickSong = CoreLearningProcess(par, pop, chickInd, NewSong, FatherSong);
return(ChickSong);
}
//Reset for next run
private static Population UpdateDeathProbabilities(SimParams par, Population pop,
int[] fatherInd)
{
//get death probs for next step
if (pop.SurvivalChance.Count > 2)
{
for (int i = par.MaxAge; i > 1; i--)
{
pop.SurvivalChance[i] = pop.SurvivalChance[i - 1];
}
}
pop.SurvivalChance[1] = pop.SurvivalStore;
pop.SurvivalStore = (float)Math.Pow(1 / (par.ChickSurvival * fatherInd.Length), 1.0 / par.MaxAge);
return(pop);
}
private static Population AddSyllables(SimParams par, Population pop,
List <int> learners, List <int>[] tutorSyls)
{
//Learn heard Syllables
List <int> Gain;
for (int i = 0; i < learners.Count; i++)
{
Gain = tutorSyls[i].Except(pop.MaleSong[learners[i]]).ToList();
pop.MaleSong[learners[i]] = CoreLearningProcess(par, pop, learners[i],
pop.MaleSong[learners[i]],
Gain);
}
return(pop);
}
//Functions for getting the ages
public static int[] InitialAgeDistribution(SimParams par)
{
int[] AgeGroup;
if (par.AgeDeath)
{
float[] AgeRates = GetAgeRates(par);
AgeGroup = GetAgeGroup(par, AgeRates);
}
else
{
List <int> AgeRange = Enumerable.Range(0, par.MaxAge + 1).ToList();
AgeGroup = par.RandomSampleEqualReplace(AgeRange, par.NumBirds);
}
return(AgeGroup);
}
public void Output(SimParams par, string filePath, string tag, bool writePar = true)
{
//Make the final .csvs
File.WriteAllText(filePath + "/" + tag + "SylRep.csv", SylRep.ToString(), Encoding.UTF8);
if (par.SaveMatch)
{
File.WriteAllText(filePath + "/" + tag + "Match.csv", Match.ToString(), Encoding.UTF8);
}
if (par.SaveAge)
{
File.WriteAllText(filePath + "/" + tag + "Age.csv", Age.ToString(), Encoding.UTF8);
}
if (par.SaveNames)
{
File.WriteAllText(filePath + "/" + tag + "Name.csv", Name.ToString(), Encoding.UTF8);
File.WriteAllText(filePath + "/" + tag + "FatherName.csv", FatherName.ToString(), Encoding.UTF8);
}
if (par.SaveLearningThreshold)
{
File.WriteAllText(filePath + "/" + tag + "LrnThrsh.csv", LearningThreshold.ToString(), Encoding.UTF8);
}
if (par.SaveAccuracy)
{
File.WriteAllText(filePath + "/" + tag + "Acc.csv", Accuracy.ToString(), Encoding.UTF8);
}
if (par.SaveChancetoForget)
{
File.WriteAllText(filePath + "/" + tag + "ChanFor.csv", ChanceForget.ToString(), Encoding.UTF8);
}
if (par.SaveChancetoInvent)
{
File.WriteAllText(filePath + "/" + tag + "ChanInv.csv", ChanceInvent.ToString(), Encoding.UTF8);
}
if (par.SaveMSong)
{
File.WriteAllText(filePath + "/" + tag + "MSong.csv", MaleSong.ToString(), Encoding.UTF8);
}
if (par.SaveFSong)
{
File.WriteAllText(filePath + "/" + tag + "FSong.csv", FemaleSong.ToString(), Encoding.UTF8);
}
//Save parameters is desired
if (writePar)
{
WriteParams(par, filePath, tag);
}
}
//Adult Learning-Specific Accessory functions
private static List <int>[] ListeningTest(SimParams par, Population pop, int[] tutors, float lisThresh)
{
/*Get syls and test whether Repsize larger than listening threshold,
* if so, randomly remove extra syllables.*/
List <int>[] TutorSyls = new List <int> [tutors.Length];
for (int i = 0; i < tutors.Length; i++)
{
TutorSyls[i] = pop.MaleSong[tutors[i]].ToList();
}
if (lisThresh >= .999f & lisThresh < 1)
{
return(TutorSyls);
}
if (lisThresh % 1 == 0)//Absolute number of sylls learned
{
int Thresh = (int)lisThresh;
int Remove;
for (int i = 0; i < TutorSyls.Length; i++)
{
if (TutorSyls[i].Count > Thresh)
{
Remove = TutorSyls[i].Count - Thresh;
par.RandomSampleEqualNoReplace(TutorSyls[i], Remove);
}
}
}
else //percentage of sylls learned
{
float Learnable;
float Remove;
for (int i = 0; i < TutorSyls.Length; i++)
{
Learnable = (TutorSyls[i].Count - par.MinLearnedSyllables) * lisThresh + par.MinLearnedSyllables;
if (Learnable < TutorSyls[i].Count)
{
Learnable = par.NextFloat() < Learnable % 1?
(float)Math.Ceiling(Learnable):(float)Math.Floor(Learnable);
Remove = TutorSyls[i].Count - Learnable;
if (Remove > 0)
{
par.RandomSampleEqualNoReplace(TutorSyls[i], (int)Remove);
}
}
}
}
return(TutorSyls);
}
private static float[] LearningPenalty(SimParams par, float[] learnThreshold)
{
float Base = par.LearningPenalty / (par.MaxAge - 1);
float[] PickChance = new float[par.NumBirds];
for (int i = 0; i < par.NumBirds; i++)
{
PickChance[i] = Base * (learnThreshold[i] - 1) + 1;
}
List <int> Cheaters = Enumerable.Range(0, PickChance.Length).Where(x => PickChance[x] < 1).ToList();
for (int i = 0; i < Cheaters.Count; i++)
{
PickChance[Cheaters[i]] = 1;
}
return(PickChance);
}
private static float[] CalculateMatchBonus(SimParams par, Population pop,
List <int> usableMales)
{
float[] MatBonus = new float[usableMales.Count];
if (par.MatchPreference != 0)
{
for (int i = 0; i < usableMales.Count; i++)
{
MatBonus[i] = par.MatchPreference * pop.Match[usableMales[i]];
}
}
else
{
MatBonus = Enumerable.Repeat(0f, usableMales.Count).ToArray();
}
return(MatBonus);
}
public static Population ChooseMates(SimParams par, Population pop)
{
//All females can pick a new mate
var Assign = AssignFemale(par, pop.MaleSong, pop.FemaleSong);
List <int>[] NewMaleSong = new List <int> [par.NumBirds];
List <int>[] NewFemaleSong = new List <int> [par.NumBirds];
for (int i = 0; i < par.NumBirds; i++)
{
NewMaleSong[i] = pop.MaleSong[Assign.MaleOrder[i]];
NewFemaleSong[i] = pop.FemaleSong[Assign.FemaleOrder[i]];
}
pop.MaleSong = NewMaleSong;
pop.FemaleSong = NewFemaleSong;
pop.Match = Assign.Match;
return(pop);
}
private static List <int> GenerateNovelSong(SimParams par)
{
//Test whether each syllable is learned
List <int> Song = new List <int>();
while (Song.Count == 0)
{
for (int i = 0; i < par.SongCore.Count; i++)
{
if (par.NextFloat() < par.SongCore[i])
{
Song.Add(i);
}
}
}
return(Song);
}
static float[] GetAgeRates(SimParams par)
{
/*Get the fraction of the population in each age group
* The last element in the Survival Rates is omitted,
* because that is the "dead" slot; no birds in the
* population of live birds can be dead.
*/
List <float> SurvivalRates = CalculateAllGenerations(par);
float[] AgeRates = new float[SurvivalRates.Count - 1];
for (int i = 0; i < AgeRates.Length; i++)
{
AgeRates[i] = SurvivalRates[i] / par.NumBirds;
AgeRates[i] = AgeRates[i] * (1 / (1 - (par.DeathThreshold / par.NumBirds)));
}
return(AgeRates);
}
public static int[] GetGlobalBirds(SimParams par, Population pop,
int learner, List <int> potentialBirds, int numBirds = 1)
{
int[] Birds;
List <int> PotentialBirds = potentialBirds.ToList();
PotentialBirds.Remove(learner);
if (numBirds == 1)
{
Birds = par.RandomSampleEqualReplace(PotentialBirds, numBirds);
}
else
{
Birds = par.RandomSampleEqualNoReplace(PotentialBirds, numBirds);
}
return(Birds);
}
