/// <summary> /// Averages specified results by realization count. /// </summary> /// <param name="results">List of results for realizations.</param> /// <returns>Ensemble result, which represents avereged values of realizations results.</returns> public static EnsembleResult AverageResults(List <RealizationResult> results) { Debug.Assert(results.Count != 0); EnsembleResult r = new EnsembleResult(results[0].NetworkSize); double rCount = results.Count; foreach (RealizationResult res in results) { r.EdgesCount += res.EdgesCount; } r.EdgesCount /= rCount; Math.Round(r.EdgesCount, 4); foreach (AnalyzeOption option in results[0].Result.Keys) { AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])option.GetType().GetField(option.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); OptionType ot = info[0].OptionType; #region EIGENVALUES if (option == AnalyzeOption.EigenValues) { FillEigenValuesResults(option, results, r); continue; } else if (option == AnalyzeOption.EigenDistanceDistribution) { FillEigenDistanceDistributionResults(option, results, r); continue; } #endregion Debug.Assert(option != AnalyzeOption.EigenValues && option != AnalyzeOption.EigenDistanceDistribution); switch (ot) { case OptionType.Global: FillDoubleResults(option, results, r); break; case OptionType.ValueList: case OptionType.Centrality: FillListResults(option, results, r); break; case OptionType.Distribution: FillDictionaryResults(option, results, r); break; case OptionType.Trajectory: FillTrajectoryResults(option, results, r); break; default: { break; } } } return(r); }
/// <summary> /// Averages specified results by realization count. /// </summary> /// <param name="results">List of results for realizations.</param> /// <returns>Ensemble result, which represents avereged values of realizations results.</returns> public static EnsembleResult AverageResults(List<RealizationResult> results) { Debug.Assert(results.Count != 0); EnsembleResult r = new EnsembleResult(); r.NetworkSize = results[0].NetworkSize; double rCount = results.Count; foreach (RealizationResult res in results) { r.EdgesCount += res.EdgesCount; } r.EdgesCount /= rCount; Math.Round(r.EdgesCount, 4); foreach (AnalyzeOption option in results[0].Result.Keys) { AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])option.GetType().GetField(option.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); OptionType ot = info[0].OptionType; #region EIGENVALUES if (option == AnalyzeOption.EigenValues) { FillEigenValuesResults(option, results, r); continue; } else if (option == AnalyzeOption.EigenDistanceDistribution) { FillEigenDistanceDistributionResults(option, results, r); continue; } #endregion Debug.Assert(option != AnalyzeOption.EigenValues && option != AnalyzeOption.EigenDistanceDistribution); switch (ot) { case OptionType.Global: FillDoubleResults(option, results, r); break; case OptionType.ValueList: case OptionType.Centrality: FillListResults(option, results, r); break; case OptionType.Distribution: case OptionType.Trajectory: FillDictionaryResults(option, results, r); break; default: { break; } } } return r; }
private static void FillEigenValuesResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r) { Debug.Assert(option == AnalyzeOption.EigenValues); List<Double> temp = new List<Double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is List<Double>); List<Double> e = res.Result[option] as List<Double>; foreach (Double k in e) temp.Add(k); } r.Result.Add(option, temp); }
private static void FillEigenDistanceDistributionResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r) { Debug.Assert(option == AnalyzeOption.EigenDistanceDistribution); SortedDictionary<Double, Double> temp = new SortedDictionary<Double, Double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is SortedDictionary<Double, Double>); SortedDictionary<Double, Double> d = res.Result[option] as SortedDictionary<Double, Double>; foreach (double k in d.Keys) { if (temp.ContainsKey(k)) temp[k] += d[k]; else temp.Add(k, d[k]); } } r.Result.Add(option, temp); }
private static void FillDoubleResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r) { double temp = 0; foreach (RealizationResult res in results) { temp += (double)(res.Result[option]) / results.Count; } r.Result.Add(option, double.IsNaN(temp) ? 0 : Math.Round(temp, 4)); }
private static void FillDictionaryResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r) { SortedDictionary<Double, Double> temp = new SortedDictionary<Double, Double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is SortedDictionary<Double, Double>); SortedDictionary<Double, Double> d = res.Result[option] as SortedDictionary<Double, Double>; foreach (double k in d.Keys) { if (temp.ContainsKey(k)) temp[k] += Math.Round(d[k] / results.Count, 4); else temp.Add(k, Math.Round(d[k] / results.Count, 4)); } } r.Result.Add(option, temp); }
/// <summary> /// Averages specified results by realization count. /// </summary> /// <param name="results">List of results for realizations.</param> /// <returns>Ensemble result, which represents avereged values of realizations results.</returns> public static EnsembleResult AverageResults(List<RealizationResult> results) { EnsembleResult r = new EnsembleResult(); r.NetworkSize = results[0].NetworkSize; r.Result = new Dictionary<AnalyzeOption, object>(); double rCount = results.Count; foreach (RealizationResult res in results) { r.EdgesCount += res.EdgesCount; } r.EdgesCount /= rCount; Math.Round(r.EdgesCount, 4); foreach (AnalyzeOption option in results[0].Result.Keys) { AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])option.GetType().GetField(option.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); Type t = info[0].RealizationResultType; if(t.Equals(typeof(Double))) { double temp = 0; foreach (RealizationResult res in results) { temp += (double)(res.Result[option]) / rCount; } r.Result.Add(option, Math.Round(temp, 4)); } else if(t.Equals(typeof(UInt32))) { double temp = 0; uint uTemp = 0; foreach (RealizationResult res in results) { uTemp = (UInt32)res.Result[option]; temp += uTemp / rCount; } r.Result.Add(option, Math.Round(temp, 4)); } else if(t.Equals(typeof(List<Double>))) { List<Double> temp = new List<double>(results[0].Result[option] as List<Double>); for (int i = 0; i < temp.Count; ++i) temp[i] /= rCount; // TODO check the theory logic of averaging eigen values and round to 3 digits /*for (int i = 1; i < results.Count; ++i) { List<Double> l = results[i].Result[option] as List<Double>; for (int j = 0; j < l.Count; ++j) temp[j] += l[j] / rCount; }*/ r.Result.Add(option, temp); } else if (t.Equals(typeof(SortedDictionary<Double, UInt32>))) { SortedDictionary<Double, Double> temp = new SortedDictionary<double, double>(); foreach (RealizationResult res in results) { SortedDictionary<Double, UInt32> d = res.Result[option] as SortedDictionary<Double, UInt32>; foreach (double k in d.Keys) { if (temp.ContainsKey(k)) temp[k] += Math.Round(d[k] / rCount, 3); else temp.Add(k, Math.Round(d[k] / rCount, 3)); } } r.Result.Add(option, temp); } else if (t.Equals(typeof(SortedDictionary<UInt32, UInt32>))) { SortedDictionary<UInt32, Double> temp = new SortedDictionary<uint, double>(); foreach (RealizationResult res in results) { SortedDictionary<UInt32, UInt32> d = res.Result[option] as SortedDictionary<UInt32, UInt32>; foreach (uint k in d.Keys) { if (temp.ContainsKey(k)) temp[k] += Math.Round(d[k] / rCount, 3); else temp.Add(k, Math.Round(d[k] / rCount, 3)); } } r.Result.Add(option, temp); } else if (t.Equals(typeof(SortedDictionary<UInt32, Double>))) { SortedDictionary<UInt32, Double> temp = new SortedDictionary<uint, double>(); foreach (RealizationResult res in results) { SortedDictionary<UInt32, Double> d = res.Result[option] as SortedDictionary<UInt32, Double>; foreach (uint k in d.Keys) { if (temp.ContainsKey(k)) temp[k] += Math.Round(d[k] / rCount, 3); else temp.Add(k, Math.Round(d[k] / rCount, 3)); } } r.Result.Add(option, temp); } else if (t.Equals(typeof(SortedDictionary<UInt16, Double>))) { SortedDictionary<UInt16, Double> temp = new SortedDictionary<UInt16, Double>(); foreach (RealizationResult res in results) { SortedDictionary<UInt16, Double> d = res.Result[option] as SortedDictionary<UInt16, Double>; foreach (UInt16 k in d.Keys) { if (temp.ContainsKey(k)) temp[k] += Math.Round(d[k] / rCount, 3); else temp.Add(k, Math.Round(d[k] / rCount, 3)); } } r.Result.Add(option, temp); } } return r; }
private void SaveEnsembleResult(EnsembleResult e, int id) { foreach (AnalyzeOption opt in e.Result.Keys) { AnalyzeOptionInfo info = ((AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false))[0]; OptionType optionType = info.OptionType; switch (optionType) { case OptionType.Global: SaveToGlobalSheet(id, info, e.Result[opt]); break; case OptionType.ValueList: SaveValueListSheet(id, info, e.Result[opt]); break; case OptionType.Centrality: SaveCentralitySheet(id, info, e.Result[opt]); break; case OptionType.Distribution: case OptionType.Trajectory: SaveDistributionSheet(id, info, e.Result[opt]); break; default: break; } } }
/// <summary> /// Calculates the average value of specified global analyze option. /// </summary> /// <param name="opt">Analyze option.</param> public void CalculateGlobalOption(AnalyzeOption opt) { if (EnsembleResultsAvg.Count != 0 && EnsembleResultsAvg[0].Result.ContainsKey(opt)) return; ResearchResult tr = null; AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); Debug.Assert(info[0].OptionType == OptionType.Global); double avg = 0; foreach (Guid id in researches) { tr = StatSessionManager.GetResearchResult(id); Debug.Assert(tr.EnsembleResults.Count == 1); Debug.Assert(tr.EnsembleResults[0].Result[opt] != null); avg += Convert.ToDouble(tr.EnsembleResults[0].Result[opt]) * tr.RealizationCount; } avg /= RealizationCountSum; EnsembleResult er = null; if (EnsembleResultsAvg.Count == 0) { er = new EnsembleResult(); EnsembleResultsAvg.Add(er); } else er = EnsembleResultsAvg[0]; er.Result.Add(opt, Math.Round(avg, 4)); }
private void SaveEnsembleResult(EnsembleResult e, int id) { writer.WriteStartElement("Ensemble"); writer.WriteAttributeString("id", id.ToString()); foreach (AnalyzeOption opt in e.Result.Keys) { AnalyzeOptionInfo info = ((AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false))[0]; OptionType optionType = info.OptionType; switch (optionType) { case OptionType.Global: writer.WriteElementString(opt.ToString(), e.Result[opt].ToString()); break; case OptionType.ValueList: writer.WriteStartElement(opt.ToString()); SaveValueList(e.Result[opt]); writer.WriteEndElement(); break; case OptionType.Centrality: // TODO add code break; case OptionType.Distribution: case OptionType.Trajectory: writer.WriteStartElement(opt.ToString()); SaveDistribution(info, e.Result[opt]); writer.WriteEndElement(); break; default: break; } } writer.WriteEndElement(); }
private void LoadEnsembleResults(ResearchResult r) { while (reader.Read()) { if (reader.Name == "Ensemble" && !reader.IsEmptyElement) { EnsembleResult e = new EnsembleResult(); e.NetworkSize = r.Size; e.EdgesCount = r.Edges; e.Result = new Dictionary<AnalyzeOption, Object>(); reader.Read(); while (reader.NodeType != XmlNodeType.EndElement) { AnalyzeOption opt = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), reader.Name); AnalyzeOptionInfo optInfo = (AnalyzeOptionInfo)(opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false)[0]); switch (optInfo.OptionType) { case OptionType.Global: e.Result.Add(opt, reader.ReadElementContentAsDouble()); break; case OptionType.ValueList: e.Result.Add(opt, LoadValueList()); reader.Read(); break; case OptionType.Distribution: case OptionType.Trajectory: e.Result.Add(opt, LoadDistribution()); reader.Read(); break; default: break; } } r.EnsembleResults.Add(e); } } }
private static void FillTrajectoryResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r) { SortedDictionary <Double, Double> temp = new SortedDictionary <Double, Double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is SortedDictionary <Double, Double>); SortedDictionary <Double, Double> d = res.Result[option] as SortedDictionary <Double, Double>; foreach (KeyValuePair <double, double> k in d) { if (temp.ContainsKey(k.Key)) { temp[k.Key] += k.Value / results.Count; } else { temp.Add(k.Key, k.Value / results.Count); } } } r.Result.Add(option, temp); }
private static void FillListResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r) { List <Double> temp = new List <double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is List <Double>); List <Double> l = res.Result[option] as List <Double>; for (int j = 0; j < l.Count; ++j) { if (j < temp.Count()) { temp[j] += l[j] / results.Count; } else { temp.Add(l[j] / results.Count); } } } r.Result.Add(option, temp); }
private static void FillDoubleResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r) { double temp = 0; foreach (RealizationResult res in results) { temp += (double)(res.Result[option]) / results.Count; } r.Result.Add(option, double.IsNaN(temp) ? 0 : Math.Round(temp, 4)); }
private static void FillEigenValuesResults(AnalyzeOption option, List <RealizationResult> results, EnsembleResult r) { Debug.Assert(option == AnalyzeOption.EigenValues); List <Double> temp = new List <Double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is List <Double>); List <Double> e = res.Result[option] as List <Double>; foreach (Double k in e) { temp.Add(k); } } r.Result.Add(option, temp); }
private static void FillListResults(AnalyzeOption option, List<RealizationResult> results, EnsembleResult r) { List<Double> temp = new List<double>(); foreach (RealizationResult res in results) { Debug.Assert(res.Result[option] is List<Double>); List<Double> l = res.Result[option] as List<Double>; for (int j = 0; j < l.Count; ++j) { if (j < temp.Count()) temp[j] += l[j] / results.Count; else temp.Add(l[j] / results.Count); } } r.Result.Add(option, temp); }
private void LoadEnsembleResults(Workbook book, ResearchResult r) { EnsembleResult e = new EnsembleResult(); e.NetworkSize = r.Size; e.EdgesCount = r.Edges; e.Result = new Dictionary<AnalyzeOption, Object>(); Array existingOptions = Enum.GetValues(typeof(AnalyzeOption)); foreach (AnalyzeOption opt in existingOptions) { AnalyzeOptionInfo optInfo = (AnalyzeOptionInfo)(opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false)[0]); switch (optInfo.OptionType) { case OptionType.Global: Double v = FindValueInGlobals(book, optInfo.FullName); if ( v != -1) e.Result.Add(opt, v); break; case OptionType.ValueList: Object vl = LoadValueList(book, optInfo); if (vl != null) e.Result.Add(opt, vl); break; case OptionType.Distribution: case OptionType.Trajectory: Object vd = LoadDistribution(book, optInfo); if (vd != null) e.Result.Add(opt, vd); break; default: break; } } r.EnsembleResults.Add(e); }
/// <summary> /// Calculates the average distribution of specified distributed analyze option. /// </summary> /// <param name="opt">Analyze option.</param> public void CalculateDistributedOption(AnalyzeOption opt) { if (EnsembleResultsAvg.Count != 0 && EnsembleResultsAvg[0].Result.ContainsKey(opt)) return; AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); Debug.Assert(info[0].OptionType == OptionType.Distribution); EnsembleResult er = null; if (EnsembleResultsAvg.Count == 0) { er = new EnsembleResult(); EnsembleResultsAvg.Add(er); } else er = EnsembleResultsAvg[0]; er.Result.Add(opt, CalculateDoubleAverage(opt)); }