/// <summary>
/// Assigns a value to <see cref="College"/> at random based on the given values
/// </summary>
/// <param name="homeState"></param>
/// <param name="hsGradDt"></param>
protected internal void AssignRandomCollege(string homeState, DateTime?hsGradDt)
{
if (hsGradDt == null)
{
return;
}
//get college grad data for same state as hs
var univGradData =
UsStateData.GetStateData(homeState)?.PercentOfGrads
.FirstOrDefault(x => x.Item1 == (OccidentalEdu.Bachelor | OccidentalEdu.Grad));
var bachelorGradRate = univGradData?.Item2 ??
AmericanUniversity.DefaultNationalAvgs.First(
x => x.Key == (OccidentalEdu.Bachelor | OccidentalEdu.Grad)).Value;
//roll for some college
if (Etx.RandomRollAboveOrAt((int)Math.Round(bachelorGradRate * 2), Etx.Dice.OneHundred))
{
AssignEduFlagAndLevel();
return;
}
//pick a univ
var univ = GetAmericanUniversity(homeState);
if (univ == null)
{
AssignEduFlagAndLevel();
return;
}
if (!Etx.RandomRollBelowOrAt((int)Math.Round(bachelorGradRate * 10), Etx.Dice.OneThousand))
{
//dropped out of college
AddUniversity(univ, null);
AssignEduFlagAndLevel();
return;
}
//college grad
//get a date for when amer would grad from college
var univGradDt = GetRandomGraduationDate(hsGradDt.Value, AmericanUniversity.YearsInUndergradCollege);
AddUniversity(univ, univGradDt);
//try for post-grad
var postGradRate = AmericanUniversity.DefaultNationalAvgs.First(
x => x.Key == (OccidentalEdu.Master | OccidentalEdu.Grad)).Value;
if (Etx.RandomRollBelowOrAt((int)postGradRate * 10, Etx.Dice.OneThousand))
{
var postGradDt = GetRandomGraduationDate(univGradDt, AmericanUniversity.YearsInPostgradCollege);
var postGradUniv = GetAmericanUniversity(homeState);
AddUniversity(postGradUniv, postGradDt);
}
AssignEduFlagAndLevel();
}
/// <summary>
/// Assigns the Msa and AverageEarnings properties based on a match to the underlying data.
/// </summary>
/// <param name="node"></param>
protected internal void ParseCityXmlNode(XmlNode node)
{
const string METRO = "Metro";
const string MSA_TYPE = "msa-type";
const string CBSA_TYPE = "cbsa-type";
var cityNode = node as XmlElement;
if (!String.IsNullOrWhiteSpace(cityNode?.Attributes[MSA_CODE]?.Value))
{
Msa = new MStatArea {
Value = cityNode.Attributes[MSA_CODE].Value
};
if (!String.IsNullOrWhiteSpace(cityNode.Attributes[MSA_TYPE]?.Value))
{
Msa.MsaType = cityNode.Attributes[MSA_TYPE].Value == METRO
? UrbanCentric.City | UrbanCentric.Large
: UrbanCentric.City | UrbanCentric.Small;
}
}
if (!String.IsNullOrWhiteSpace(cityNode?.Attributes[CBSA_CODE]?.Value))
{
Msa = new MStatArea {
Value = cityNode.Attributes[CBSA_CODE].Value
};
if (!String.IsNullOrWhiteSpace(cityNode.Attributes[CBSA_TYPE]?.Value))
{
Msa.MsaType = cityNode.Attributes[CBSA_TYPE].Value == METRO
? UrbanCentric.City | UrbanCentric.Large
: UrbanCentric.City | UrbanCentric.Small;
}
}
AverageEarnings = GetAvgEarningsPerYear(cityNode) ??
UsStateData.GetStateData(StateName)?.AverageEarnings;
}
public void TestGetStateData()
{
var testStateName = "Maryland";
var testState = UsState.GetStateByName(testStateName);
var testResult = UsStateData.GetStateData(testState.ToString());
Assert.IsNotNull(testResult);
Assert.AreEqual("Maryland", testResult.StateName);
Assert.IsNotNull(testResult.AverageEarnings);
Assert.AreNotEqual(0, testResult.EmploymentSectors.Count);
Assert.AreNotEqual(0, testResult.PercentOfGrads.Count);
Assert.AreNotEqual(0, testResult.PropertyCrimeRate.Count);
Assert.AreNotEqual(0, testResult.ViolentCrimeRate.Count);
var percentCollegeGrad =
testResult.PercentOfGrads.FirstOrDefault(x => x.Item1 == (OccidentalEdu.Bachelor | OccidentalEdu.Grad));
Assert.AreNotEqual(0, percentCollegeGrad);
System.Diagnostics.Debug.WriteLine(percentCollegeGrad);
for (var i = 0; i < 100; i++)
{
var attempt = Etx.RandomRollAboveOrAt((int)Math.Round(percentCollegeGrad.Item2 * 2), Etx.Dice.OneHundred);
System.Diagnostics.Debug.WriteLine(attempt);
}
//expected to resolve to national
testResult = UsStateData.GetStateData(null);
Assert.IsNotNull(testResult);
Assert.AreEqual("United States", testResult.StateName);
Assert.IsNotNull(testResult);
Assert.IsNotNull(testResult.AverageEarnings);
Assert.AreNotEqual(0, testResult.EmploymentSectors.Count);
Assert.AreNotEqual(0, testResult.PercentOfGrads.Count);
Assert.AreNotEqual(0, testResult.PropertyCrimeRate.Count);
Assert.AreNotEqual(0, testResult.ViolentCrimeRate.Count);
}
/// <summary>
/// Assigns a value to <see cref="HighSchool"/> at random based on the given inputs
/// </summary>
/// <param name="homeState"></param>
/// <param name="zipCode"></param>
/// <param name="isLegalAdult"></param>
/// <param name="dtAtAge18"></param>
/// <param name="hsGradDt"></param>
/// <returns></returns>
protected internal bool AssignRandomHighSchool(string homeState, string zipCode, bool isLegalAdult, DateTime dtAtAge18,
out DateTime?hsGradDt)
{
hsGradDt = null;
//get hs grad data for state amer lived in when 18
var hsGradData =
UsStateData.GetStateData(homeState)?.PercentOfGrads
.FirstOrDefault(x => x.Item1 == (OccidentalEdu.HighSchool | OccidentalEdu.Grad));
//determine prob. of having hs grad
var hsGradRate = hsGradData?.Item2 ?? AmericanHighSchool.DF_NATL_AVG;
//first try city, then state, last natl
var hss = AmericanHighSchool.GetHighSchoolsByZipCode(zipCode)
?? AmericanHighSchool.GetHighSchoolsByState(homeState);
var hs = hss.Length > 1 ? hss[Etx.RandomInteger(0, hss.Length - 1)] : hss.First();
//still in hs or dropped out
if (!isLegalAdult || Etx.RandomRollAboveOrAt((int)Math.Round(hsGradRate) + 1, Etx.Dice.OneHundred))
{
//assign grad hs but no date
_highSchools.Add(new AmericanHighSchoolStudent(hs));
AssignEduFlagAndLevel();
return(false);
}
//get a date of when amer would be grad'ing from hs
hsGradDt = GetRandomGraduationDate(dtAtAge18.AddYears(-4), AmericanHighSchool.YearsInHighSchool, true);
//assign grad hs with grad date
_highSchools.Add(new AmericanHighSchoolStudent(hs)
{
Graduation = hsGradDt
});
return(true);
}
public void TestSolvePercentHsGradByStateAndRace()
{
//test resolves to simple natl average given no input
var testResult = AmericanSchoolBase.SolvePercentGradByStateAndRace(null, null);
//test resolves to natl avg's when no state
Assert.AreEqual(89.6, testResult);
testResult = AmericanSchoolBase.SolvePercentGradByStateAndRace(null, NorthAmericanRace.Mixed);
Assert.AreEqual(89.6, testResult);
testResult = AmericanSchoolBase.SolvePercentGradByStateAndRace(null, NorthAmericanRace.AmericanIndian);
Assert.AreEqual(77.6, testResult);
var testState = UsState.GetStateByPostalCode("CA");
var testStateData = UsStateData.GetStateData(testState.ToString());
Assert.IsNotNull(testStateData);
//percent-highschool-grad="80.6"
//asian="89.0" natl-percent="82.0"
// 89 - 82 = 7
testResult = AmericanSchoolBase.SolvePercentGradByStateAndRace(testState.ToString(), NorthAmericanRace.Asian);
Assert.AreEqual(87.6, testResult);
//american-indian="70.0"
// 70 - 82 = -12
testResult = AmericanSchoolBase.SolvePercentGradByStateAndRace(testState.ToString(), NorthAmericanRace.AmericanIndian);
Assert.AreEqual(68.6, testResult);
testState = UsState.GetStateByPostalCode("ID");
Assert.IsNotNull(testState);
Assert.IsNotNull(UsStateData.GetStateData(testState.ToString()));
testResult = AmericanSchoolBase.SolvePercentGradByStateAndRace(testState.ToString(), NorthAmericanRace.Asian, OccidentalEdu.Bachelor | OccidentalEdu.Grad);
//percent-college-grad="23.9"
//
//asian="54.0" natl-percent="30.0"
// 54.0 - 30.0 = 24, 23.9+24 = 47.9
Assert.AreEqual(47.9, testResult);
}
/// <summary>
/// Difference of national avg to race average added to state average.
/// </summary>
/// <param name="state"></param>
/// <param name="race"></param>
/// <param name="edu"></param>
/// <returns></returns>
public static double SolvePercentGradByStateAndRace(string state, NorthAmericanRace?race,
OccidentalEdu edu = OccidentalEdu.HighSchool | OccidentalEdu.Grad)
{
AmericanRacePercents p;
p = edu >= OccidentalEdu.Bachelor ? AmericanUniversity.NatlGradRate() : AmericanHighSchool.NatlGradRate();
var stateAvg = p.National;
var natlAvg = p.National;
var stateData = UsStateData.GetStateData(state);
if (stateData?.PercentOfGrads != null && stateData.PercentOfGrads.Count > 0)
{
var f = stateData.PercentOfGrads.FirstOrDefault(x => x.Item1 == edu);
if (f != null)
{
stateAvg = Math.Round(f.Item2, 1);
}
}
var raceNatlAvg = new Dictionary <NorthAmericanRace, double>
{
{ NorthAmericanRace.AmericanIndian, p.AmericanIndian - natlAvg },
{ NorthAmericanRace.Asian, p.Asian - natlAvg },
{ NorthAmericanRace.Hispanic, p.Hispanic - natlAvg },
{ NorthAmericanRace.Black, p.Black - natlAvg },
{ NorthAmericanRace.White, p.White - natlAvg },
{ NorthAmericanRace.Pacific, p.Pacific - natlAvg },
{ NorthAmericanRace.Mixed, p.Mixed - natlAvg }
};
if (race == null || !raceNatlAvg.ContainsKey(race.Value))
{
return(Math.Round(stateAvg, 1));
}
return(Math.Round(stateAvg + raceNatlAvg[race.Value], 1));
}
