private SortedDictionary <Double, Double> CalculateDoubleAverage(AnalyzeOption opt) { SortedDictionary <Double, Double> temp = new SortedDictionary <Double, Double>(); ResearchResult tr = null; foreach (Guid id in researches) { tr = StatSessionManager.GetResearchResult(id); Debug.Assert(tr.EnsembleResults.Count == 1); // TODO fix it if (!tr.EnsembleResults[0].Result.ContainsKey(opt)) { continue; } Debug.Assert(tr.EnsembleResults[0].Result[opt] != null); Debug.Assert(tr.EnsembleResults[0].Result[opt] is SortedDictionary <Double, Double>); SortedDictionary <Double, Double> d = tr.EnsembleResults[0].Result[opt] as SortedDictionary <Double, Double>; foreach (KeyValuePair <Double, Double> k in d) { double value = Math.Round(k.Value * tr.RealizationCount / RealizationCountSum, 4); if (temp.ContainsKey(k.Key)) { temp[k.Key] += value; } else { temp.Add(k.Key, value); } } } return(temp); }
private void FillOptionsPanel(Panel p, OptionType ot) { p.Controls.Clear(); AnalyzeOption availableOptions = StatSessionManager.GetAvailableAnalyzeOptions(GetCurrentResearchType(), GetCurrentModelType()); Array existingOptions = Enum.GetValues(typeof(AnalyzeOption)); int location = 0; foreach (AnalyzeOption opt in existingOptions) { if ((availableOptions & opt) == opt && opt != AnalyzeOption.None) { if (!StatSessionManager.HasOptionType(opt, ot)) { continue; } CheckBox cb = new CheckBox(); cb.Name = opt.ToString(); cb.Text = opt.ToString(); cb.AutoSize = true; cb.Location = new Point(10, (location++) * 20 + 5); cb.Checked = false; p.Controls.Add(cb); } } }
public static AbstractNetwork CreateNetworkByType(ModelType mt, String rName, ResearchType rType, GenerationType gType, Dictionary <ResearchParameter, object> rParams, Dictionary <GenerationParameter, object> genParams, AnalyzeOption AnalyzeOptions, ContainerMode mode) { ModelTypeInfo[] info = (ModelTypeInfo[])mt.GetType().GetField(mt.ToString()).GetCustomAttributes(typeof(ModelTypeInfo), false); Type t = Type.GetType(info[0].Implementation); Type[] constructTypes = new Type[] { typeof(String), typeof(ResearchType), typeof(GenerationType), typeof(Dictionary <ResearchParameter, object>), typeof(Dictionary <GenerationParameter, object>), typeof(AnalyzeOption), typeof(ContainerMode) }; object[] invokeParams = new object[] { rName, rType, gType, rParams, genParams, AnalyzeOptions, mode }; return((AbstractNetwork)t.GetConstructor(constructTypes).Invoke(invokeParams)); }
// TODO check // private void FillEigenDistanceDistributionResults(AnalyzeOption option, RealizationResult result) { Debug.Assert(option == AnalyzeOption.EigenDistanceDistribution); Debug.Assert(result.Result[option] is SortedDictionary <Double, Double>); SortedDictionary <Double, Double> d = result.Result[option] as SortedDictionary <Double, Double>; if (!Result.ContainsKey(option)) { Result.Add(option, new SortedDictionary <Double, Double>()); } Debug.Assert(Result[option] is SortedDictionary <Double, Double>); SortedDictionary <Double, Double> temp = Result[option] as SortedDictionary <Double, Double>; foreach (KeyValuePair <double, double> k in d) { if (temp.ContainsKey(k.Key)) { temp[k.Key] = CalculateNextAverageValue(temp[k.Key], k.Value); } else { temp.Add(k.Key, k.Value); } } }
/// <summary> /// Sets analyze options for specified research. /// </summary> /// <param name="id">ID of research.</param> /// <param name="o">Analyze options to set (flag).</param> /// <node>param o must be subset from available analyze options.</node> public static void SetAnalyzeOptions(Guid id, AnalyzeOption o) { try { if (existingResearches[id].StatusInfo.Status == ResearchStatus.NotStarted) { AnalyzeOption opt = GetAvailableAnalyzeOptions(id); if ((opt | o) != opt) { throw new CoreException("Specified option is not available for current research and model type."); } else { existingResearches[id].AnalyzeOption = o; } } else { throw new CoreException("Unable to modify research after start."); } } catch (KeyNotFoundException) { throw new CoreException("Specified research does not exists."); } }
private void InitializeAnalyzeOptionsGroup() { optionsPanel.Controls.Clear(); AnalyzeOption availableOptions = SessionManager.GetAvailableAnalyzeOptions(rType, GetCurrentModelType()); AnalyzeOption checkedOptions = AnalyzeOption.None; if (dType != DialogType.Create) { checkedOptions = SessionManager.GetAnalyzeOptions(researchId); } Array existingOptions = Enum.GetValues(typeof(AnalyzeOption)); int location = 0; foreach (AnalyzeOption opt in existingOptions) { if ((availableOptions & opt) == opt && opt != AnalyzeOption.None) { CheckBox cb = new CheckBox(); cb.Name = opt.ToString(); cb.Text = opt.ToString(); cb.AutoSize = true; cb.Location = new Point(10, (location++) * 20 + 5); cb.Checked = false; optionsPanel.Controls.Add(cb); if (dType != DialogType.Create && (checkedOptions & opt) == opt) { cb.Checked = true; } } } }
private bool SetAnalyzeOptionsValues() { AnalyzeOption opts = AnalyzeOption.None; int numOfSelectedItems = 0; foreach (Control c in AnalyzeOptionsStackPanel.Children) { Debug.Assert(c is CheckBox); CheckBox cc = c as CheckBox; // TODO maybe better content and text AnalyzeOption current = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), cc.Content.ToString()); if (cc.IsChecked.GetValueOrDefault()) { opts |= current; numOfSelectedItems++; } } if ((researchType == ResearchType.Activation || researchType == ResearchType.Evolution) && numOfSelectedItems != 1) { MessageBox.Show("Exactly one item form Analyze Options must be selected."); return(false); } LabSessionManager.SetAnalyzeOptions(opts); return(true); }
private bool Check(AnalyzeOption o, RealizationResult rn, ResearchResult rr) { Debug.Assert(rn.Result.ContainsKey(o)); Debug.Assert(rn.Result[o] != null); Debug.Assert(rr.EnsembleResults.Count() > 0); if (!rr.EnsembleResults[0].Result.ContainsKey(o)) return true; Debug.Assert(rr.EnsembleResults[0].Result[o] != null); AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])o.GetType().GetField(o.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); OptionType ot = info[0].OptionType; switch (ot) { case OptionType.Global: Double v1 = Convert.ToDouble(rn.Result[o]); Double v2 = Convert.ToDouble(rr.EnsembleResults[0].Result[o]); return Math.Round(v1, 4) == v2; case OptionType.Distribution: case OptionType.Trajectory: Debug.Assert(rn.Result[o] is SortedDictionary<Double, Double>); Debug.Assert(rr.EnsembleResults[0].Result[o] is SortedDictionary<Double, Double>); SortedDictionary<Double, Double> d1 = rn.Result[o] as SortedDictionary<Double, Double>; SortedDictionary<Double, Double> d2 = rr.EnsembleResults[0].Result[o] as SortedDictionary<Double, Double>; return CheckDictionary(d1, d2); default: Debug.Assert(false); break; } return true; }
public GraphicsTab(AnalyzeOption o, SortedDictionary <Double, Double> v) { option = o; values = v; drawingOptions = new DrawingOption(Color.Black, false); statisticsOptions = new StatisticsOption(ApproximationType.None, ThickeningType.None, 0); InitializeComponent(); }
public BANetwork(String rName, Dictionary<ResearchParameter, object> rParams, Dictionary<GenerationParameter, object> genParams, AnalyzeOption analyzeOpts) : base(rName, rParams, genParams, analyzeOpts) { networkGenerator = new BANetworkGenerator(); networkAnalyzer = new NonHierarchicAnalyzer(this); }
public GraphicsTab(AnalyzeOption o, SortedDictionary<Double, Double> v) { option = o; values = v; drawingOptions = new DrawingOption(Color.Black, false); statisticsOptions = new StatisticsOption(ApproximationType.None, ThickeningType.None, 0); InitializeComponent(); }
// TODO check // private void FillDoubleResults(AnalyzeOption option, RealizationResult result) { if (!Result.ContainsKey(option)) { Result.Add(option, 0.0); } Result[option] = CalculateNextAverageValue((Double)Result[option], (Double)result.Result[option]); }
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)); }
public RegularHierarchicNetwork(String rName, GenerationType gType, Dictionary<ResearchParameter, object> rParams, Dictionary<GenerationParameter, object> genParams, AnalyzeOption analyzeOpts) : base(rName, gType, rParams, genParams, analyzeOpts) { networkGenerator = new RegularHierarchicNetworkGenerator(); networkAnalyzer = new RegularHierarchicNetworkAnalyzer(this); }
public NonRegularHierarchicNetwork(String rName, ResearchType rType, GenerationType gType, Dictionary <ResearchParameter, object> rParams, Dictionary <GenerationParameter, object> genParams, AnalyzeOption analyzeOpts, ContainerMode mode) : base(rName, rType, gType, rParams, genParams, analyzeOpts, mode) { networkGenerator = new NonRegularHierarchicNetworkGenerator(mode); networkAnalyzer = new NonRegularHierarchicNetworkAnalyzer(this); }
public GraphicsTab(String rName, AnalyzeOption o, SortedDictionary <Double, Double> v) { researchName = rName; option = o; values = v; drawingOptions = new DrawingOption(Color.Black, true); statisticsOptions = new StatisticsOption(ApproximationType.None, ThickeningType.None, 0); InitializeComponent(); InitializeChart(); }
public WSNetwork(String rName, ResearchType rType, GenerationType gType, TracingType tType, Dictionary <ResearchParameter, Object> rParams, Dictionary <GenerationParameter, Object> genParams, AnalyzeOption analyzeOpts) : base(rName, rType, gType, tType, rParams, genParams, analyzeOpts) { networkGenerator = new WSNetworkGenerator(); networkAnalyzer = new NonHierarchicAnalyzer(this); }
public AbstractNetwork(String rName, Dictionary<ResearchParameter, object> rParams, Dictionary<GenerationParameter, object> genParams, AnalyzeOption AnalyzeOptions) { ResearchName = rName; ResearchParameterValues = rParams; GenerationParameterValues = genParams; this.AnalyzeOptions = AnalyzeOptions; NetworkResult = new RealizationResult(); }
protected int GetAnalyzeOptionsCount() { int counter = 0; Array existingOptions = Enum.GetValues(typeof(AnalyzeOption)); foreach (AnalyzeOption opt in existingOptions) { if (AnalyzeOption.HasFlag(opt) && opt != AnalyzeOption.None) { ++counter; } } return(counter); }
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); }
public AbstractNetwork(String rName, ResearchType rType, GenerationType gType, TracingType tType, Dictionary <ResearchParameter, Object> rParams, Dictionary <GenerationParameter, Object> genParams, AnalyzeOption AnalyzeOptions) { ResearchName = rName; ResearchType = rType; GenerationType = gType; TracingType = tType; ResearchParameterValues = rParams; GenerationParameterValues = genParams; this.AnalyzeOptions = AnalyzeOptions; NetworkResult = new RealizationResult(); }
protected AbstractNetwork(String rName, ResearchType rType, GenerationType gType, Dictionary <ResearchParameter, object> rParams, Dictionary <GenerationParameter, object> genParams, AnalyzeOption AnalyzeOptions, ContainerMode mode) { this.containerMode = mode; ResearchName = rName; ResearchType = rType; GenerationType = gType; ResearchParameterValues = rParams; GenerationParameterValues = genParams; this.AnalyzeOptions = AnalyzeOptions; NetworkResult = new RealizationResult(); }
public Object CalculateOption(AnalyzeOption option) { switch (option) { case AnalyzeOption.AvgClusteringCoefficient: return CalculateAverageClusteringCoefficient(); case AnalyzeOption.AvgDegree: return CalculateAverageDegree(); case AnalyzeOption.AvgPathLength: return CalculateAveragePath(); case AnalyzeOption.ClusteringCoefficientDistribution: return CalculateClusteringCoefficientDistribution(); case AnalyzeOption.ClusteringCoefficientPerVertex: return CalculateClusteringCoefficientPerVertex(); case AnalyzeOption.CompleteComponentDistribution: return CalculateCompleteComponentDistribution(); case AnalyzeOption.ConnectedComponentDistribution: return CalculateConnectedComponentDistribution(); case AnalyzeOption.CycleDistribution: // TODO return CalculateCycleDistribution(1, 1); case AnalyzeOption.Cycles3: return CalculateCycles3(); case AnalyzeOption.Cycles3Eigen: return CalculateCycles3Eigen(); case AnalyzeOption.Cycles3Trajectory: return CalculateCycles3Trajectory(); case AnalyzeOption.Cycles4: return CalculateCycles4(); case AnalyzeOption.Cycles4Eigen: return CalculateCycles4Eigen(); case AnalyzeOption.DegreeDistribution: return CalculateDegreeDistribution(); case AnalyzeOption.Diameter: return CalculateDiameter(); case AnalyzeOption.DistanceDistribution: return CalculateDistanceDistribution(); case AnalyzeOption.EigenDistanceDistribution: return CalculateEigenDistanceDistribution(); case AnalyzeOption.EigenValues: return CalculateEigenValues(); case AnalyzeOption.TriangleByVertexDistribution: return CalculateTriangleByVertexDistribution(); default: return null; } }
private List <AnalyzeOption> GetCheckedOptions(Panel p) { List <AnalyzeOption> o = new List <AnalyzeOption>(); foreach (Control c in p.Controls) { Debug.Assert(c is CheckBox); CheckBox cc = c as CheckBox; AnalyzeOption current = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), cc.Name); if (cc.Checked) { o.Add(current); } } return(o); }
// TODO check // private void FillEigenValuesResults(AnalyzeOption option, RealizationResult result) { Debug.Assert(option == AnalyzeOption.EigenValues); Debug.Assert(result.Result[option] is List <Double>); List <Double> e = result.Result[option] as List <Double>; if (!Result.ContainsKey(option)) { Result.Add(option, new List <Double>()); } Debug.Assert(result.Result[option] is List <Double>); List <Double> temp = result.Result[option] as List <Double>; foreach (Double k in e) { temp.Add(k); } }
private void InitializeAnalyzeOptionsGroup() { AnalyzeOptionsStackPanel.Children.Clear(); AnalyzeOption options = LabSessionManager.GetAvailableAnalyzeOptions(researchType, GetCurrentModelType()); for (int i = 0; i < Enum.GetNames(typeof(AnalyzeOption)).Length; ++i) { int k = (int)options & (1 << i); if (k != 0) { CheckBox option = new CheckBox() { Content = ((AnalyzeOption)k).ToString() }; AnalyzeOptionsStackPanel.Children.Add(option); } } }
private void LoadEnsembleResults(ResearchResult r) { while (reader.Read()) { if (reader.Name == "Ensemble" && !reader.IsEmptyElement) { EnsembleResult e = new EnsembleResult(r.Size); //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: case OptionType.Centrality: 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 void SetAnalyzeOptionsValues() { AnalyzeOption opts = SessionManager.GetAnalyzeOptions(ResultResearchId); foreach (Control c in optionsPanel.Controls) { Debug.Assert(c is CheckBox); CheckBox cc = c as CheckBox; AnalyzeOption current = (AnalyzeOption)Enum.Parse(typeof(AnalyzeOption), cc.Name); if (cc.Checked) { opts |= current; } else { opts &= ~current; } } SessionManager.SetAnalyzeOptions(ResultResearchId, opts); }
/// <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); // TODO fix it if (!tr.EnsembleResults[0].Result.ContainsKey(opt)) { continue; } 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(0); EnsembleResultsAvg.Add(er); } else { er = EnsembleResultsAvg[0]; } er.Result.Add(opt, Math.Round(avg, 4)); }
/// <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(0); EnsembleResultsAvg.Add(er); } else { er = EnsembleResultsAvg[0]; } er.Result.Add(opt, CalculateDoubleAverage(opt)); }
private void AddAnalizeOptionsList() { if (!LabSessionManager.IsResearchCreated()) { return; } AnalyzeOptionsMenuItem.Items.Clear(); AnalyzeOption options = LabSessionManager.GetAvailableAnalyzeOptions(LabSessionManager.GetResearchType(), LabSessionManager.GetResearchModelType()); for (int i = 0; i < Enum.GetNames(typeof(AnalyzeOption)).Length; ++i) { int k = (int)options & (1 << i); if (k != 0) { CheckBox option = new CheckBox() { Content = ((AnalyzeOption)k).ToString() }; AnalyzeOptionsMenuItem.Items.Add(option); } } }
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 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 void FillAnalyzeOptionsTable(Guid researchId) { analyzeOptionsTable.Rows.Clear(); AnalyzeOption availableOptions = SessionManager.GetAvailableAnalyzeOptions(researchId); AnalyzeOption checkedOptions = SessionManager.GetAnalyzeOptions(researchId); Array existingOptions = Enum.GetValues(typeof(AnalyzeOption)); foreach (AnalyzeOption opt in existingOptions) { if ((availableOptions & opt) == opt && opt != AnalyzeOption.None) { if ((checkedOptions & opt) == opt) { analyzeOptionsTable.Rows.Add(opt.ToString(), true); } else { analyzeOptionsTable.Rows.Add(opt.ToString(), false); } } } }
private bool Check(AnalyzeOption o, RealizationResult rn, ResearchResult rr) { Debug.Assert(rn.Result.ContainsKey(o)); Debug.Assert(rn.Result[o] != null); Debug.Assert(rr.EnsembleResults.Count() > 0); if (!rr.EnsembleResults[0].Result.ContainsKey(o)) { return(true); } Debug.Assert(rr.EnsembleResults[0].Result[o] != null); AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])o.GetType().GetField(o.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); OptionType ot = info[0].OptionType; switch (ot) { case OptionType.Global: Double v1 = Convert.ToDouble(rn.Result[o]); Double v2 = Convert.ToDouble(rr.EnsembleResults[0].Result[o]); return(Math.Round(v1, 4) == v2); case OptionType.Distribution: case OptionType.Trajectory: Debug.Assert(rn.Result[o] is SortedDictionary <Double, Double>); Debug.Assert(rr.EnsembleResults[0].Result[o] is SortedDictionary <Double, Double>); SortedDictionary <Double, Double> d1 = rn.Result[o] as SortedDictionary <Double, Double>; SortedDictionary <Double, Double> d2 = rr.EnsembleResults[0].Result[o] as SortedDictionary <Double, Double>; return(CheckDictionary(d1, d2)); default: Debug.Assert(false); break; } return(true); }
// TODO check // private void FillListResults(AnalyzeOption option, RealizationResult result) { if (!Result.ContainsKey(option)) { Result.Add(option, new List <Double>()); } Debug.Assert(Result[option] is List <Double>); List <Double> temp = Result[option] as List <Double>; Debug.Assert(result.Result[option] is List <Double>); List <Double> l = result.Result[option] as List <Double>; for (int j = 0; j < l.Count; ++j) { if (j < temp.Count()) { temp[j] = CalculateNextAverageValue(temp[j], l[j]); } else { temp.Add(l[j]); } } }
/// <summary> /// /// </summary> /// <param name="eIndex"></param> /// <param name="opt"></param> /// <param name="sopt"></param> /// <returns></returns> public object ApplyStatisticsOtion(int eIndex, AnalyzeOption opt, StatisticsOption sopt) { return null; }
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 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 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> /// 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)); }
public AvailableAnalyzeOption(AnalyzeOption options) { Options = options; }
/// <summary> /// Checks if specified option has specified option type/ /// </summary> /// <param name="opt">Analyze option.</param> /// <param name="ot">Analyze option type.</param> /// <returns></returns> public static bool HasOptionType(AnalyzeOption opt, OptionType ot) { AnalyzeOptionInfo[] info = (AnalyzeOptionInfo[])opt.GetType().GetField(opt.ToString()).GetCustomAttributes(typeof(AnalyzeOptionInfo), false); return (info[0].OptionType == ot); }
private SortedDictionary<Double, Double> CalculateDoubleAverage(AnalyzeOption opt) { SortedDictionary<Double, Double> temp = new SortedDictionary<Double, Double>(); ResearchResult tr = null; foreach (Guid id in researches) { tr = StatSessionManager.GetResearchResult(id); Debug.Assert(tr.EnsembleResults.Count == 1); Debug.Assert(tr.EnsembleResults[0].Result[opt] != null); Debug.Assert(tr.EnsembleResults[0].Result[opt] is SortedDictionary<Double, Double>); SortedDictionary<Double, Double> d = tr.EnsembleResults[0].Result[opt] as SortedDictionary<Double, Double>; foreach (Double k in d.Keys) { double value = Math.Round(d[k] * tr.RealizationCount / RealizationCountSum, 4); if (temp.ContainsKey(k)) temp[k] += value; else temp.Add(k, value); } } return temp; }
public static AbstractNetwork CreateNetworkByType(ModelType mt, String rName, GenerationType gType, Dictionary<ResearchParameter, object> rParams, Dictionary<GenerationParameter, object> genParams, AnalyzeOption AnalyzeOptions) { ModelTypeInfo[] info = (ModelTypeInfo[])mt.GetType().GetField(mt.ToString()).GetCustomAttributes(typeof(ModelTypeInfo), false); Type t = Type.GetType(info[0].Implementation); Type[] constructTypes = new Type[] { typeof(String), typeof(GenerationType), typeof(Dictionary<ResearchParameter, object>), typeof(Dictionary<GenerationParameter, object>), typeof(AnalyzeOption) }; object[] invokeParams = new object[] { rName, gType, rParams, genParams, AnalyzeOptions }; return (AbstractNetwork)t.GetConstructor(constructTypes).Invoke(invokeParams); }
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)); }
/// <summary> /// Sets analyze options for specified research. /// </summary> /// <param name="id">ID of research.</param> /// <param name="o">Analyze options to set (flag).</param> /// <node>param o must be subset from available analyze options.</node> public static void SetAnalyzeOptions(Guid id, AnalyzeOption o) { try { if (existingResearches[id].Status == ResearchStatus.NotStarted) { AnalyzeOption opt = GetAvailableAnalyzeOptions(id); if ((opt | o) != opt) throw new CoreException("Specified option is not available for current research and model type."); else existingResearches[id].AnalyzeOption = o; } else throw new CoreException("Unable to modify research after start."); } catch (KeyNotFoundException) { throw new CoreException("Specified research does not exists."); } }
/// <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)); }