public void ConstructorTest_Visibility()
{
var main = new MainViewModel();
main.SetDistribution("Normal");
Assert.IsTrue(main.SelectedDistribution.Instance is NormalDistribution);
AnalysisViewModel target = main.Analysis;
Assert.IsFalse(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.EqualTo);
Assert.IsFalse(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.Outside);
Assert.IsTrue(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.GreaterThan);
Assert.IsFalse(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.Between);
Assert.IsTrue(target.LeftValueVisible);
target.ComparisonIndex = target.Comparisons.IndexOf(AnalysisViewModel.LessThan);
Assert.IsFalse(target.LeftValueVisible);
}
public void ConstructorTest1()
{
MainViewModel target = new MainViewModel();
Assert.AreEqual(1, target.Estimate.Values.Count);
Assert.IsTrue(target.Distributions.Count > 0);
}
/// <summary>
/// Gets an array containing all distributions that can be dynamically build by
/// this application by inspecting Accord.NET assemblies using reflection.
/// </summary>
///
public static DistributionViewModel[] GetDistributions(MainViewModel owner)
{
// This function iterates the Accord.Statistics assembly looking for
// classes that are concrete (not abstract) and that implement the
// IUnivariateDistribution interface. Then, it attempts to create a
// DistributionViewModel from the distribution's type by using the
// DistributionViewModel.TryParse method.
var baseType = typeof(IUnivariateDistribution);
var assembly = Assembly.GetAssembly(baseType);
// Prepare and leave Accord.NET documentation parsed
var doc = GetDocumentation(assembly);
// Get all univariate distributions in Accord.NET:
var distributions = assembly.GetTypes()
.Where(p => baseType.IsAssignableFrom(p) && !p.IsAbstract && !p.IsInterface);
// Get only those that can be dynamically built:
var buildable = new List<DistributionViewModel>();
foreach (Type type in distributions)
{
DistributionViewModel distribution;
if (DistributionViewModel.TryParse(owner, type, doc, out distribution))
buildable.Add(distribution);
}
buildable.Sort((a, b) => a.Name.CompareTo(b.Name));
return buildable.ToArray();
}
private void Application_Startup(object sender, StartupEventArgs e)
{
// Create the main view model for the application
MainViewModel mainViewModel = new MainViewModel();
MainWindow wnd = new MainWindow()
{
DataContext = mainViewModel
};
wnd.Show();
}
public void ConstructorTest_Example01()
{
var main = new MainViewModel();
main.SetDistribution("Normal");
main.GetParameter("Mean").Value = 4.62;
main.GetParameter("Std. Dev.").Value = 0.23;
AnalysisViewModel target = main.Analysis;
Assert.IsNotNull(target);
compute(target, 4.35, AnalysisViewModel.Between, 4.85);
Assert.AreEqual(0.721129, target.Probability, 1e-6);
}
public void ConstructorTest_Example02()
{
var main = new MainViewModel();
main.SetDistribution("Normal");
main.GetParameter("Mean").Value = 43.3;
main.GetParameter("Std. Dev.").Value = 4.6;
AnalysisViewModel target = main.Analysis;
Assert.IsNotNull(target);
probability(target, AnalysisViewModel.GreaterThan, 0.05);
Assert.AreEqual(0, target.LeftValue, 1e-6);
Assert.AreEqual(50.86, target.RightValue, 1e-2);
}
public void Paste_SuccessTest2()
{
var main = new MainViewModel();
var target = main.Estimate;
string text = ""
+ "0.111\t2.222\n"
+ "A\tB\n"
+ "2.421\t3.141";
Clipboard.SetText(text);
target.Paste_Executed(null);
Assert.AreEqual(3, target.Values.Count);
Assert.AreEqual(0, target.Values[0].Value);
Assert.AreEqual(1, target.Values[0].Weight);
Assert.AreEqual(0.111, target.Values[1].Value);
Assert.AreEqual(2.222, target.Values[1].Weight);
Assert.AreEqual(2.421, target.Values[2].Value);
Assert.AreEqual(3.141, target.Values[2].Weight);
}
public void Generate_NotSupportedTest()
{
var main = new MainViewModel();
// Select a Folded Normal distribution
int index = main.Distributions.IndexOf(
main.Distributions.Where(x => x.Name.Contains("Folded Normal")).First());
main.SelectedDistributionIndex = index;
SpinWait.SpinUntil(() => main.SelectedDistribution.IsInitialized);
Assert.AreEqual(1, main.Estimate.Values.Count);
Assert.IsTrue(String.IsNullOrEmpty(main.Estimate.Message));
// Generate samples
Assert.AreEqual(1000, main.Estimate.NumberOfSamplesToBeGenerated);
main.Estimate.GenerateCommand.Execute(null);
Assert.AreEqual(1000, main.Estimate.Values.Count);
Assert.IsFalse(main.Estimate.Owner.SelectedDistribution.IsFittable);
Assert.IsFalse(String.IsNullOrEmpty(main.Estimate.Message));
}
public void ConstructorTest_Example07()
{
var main = new MainViewModel();
main.SetDistribution("Binomial");
main.GetParameter("Trials").Value = 2000;
main.GetParameter("Probability").Value = 0.063;
Assert.AreEqual(126, main.GetProperty("Mean").Value);
Assert.AreEqual(118.06, main.GetProperty("Variance").Value.Value, 0.005);
AnalysisViewModel target = main.Analysis;
Assert.IsNotNull(target);
compute(target, 0, AnalysisViewModel.LessThan, 135);
Assert.AreEqual(0.8099233, target.Probability, 1e-6);
}
public void Estimate_UpdateOnEditTest()
{
var main = new MainViewModel();
SpinWait.SpinUntil(() => main.SelectedDistribution.IsInitialized);
main.Estimate.IsUpdatedOnEdit = false;
main.Estimate.Values.Add(new SampleViewModel() { Value = 2 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 3 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 4 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 5 });
Assert.AreEqual(0, main.SelectedDistribution.Instance.Mean);
Assert.AreEqual(1, main.SelectedDistribution.Instance.Variance);
main.Estimate.IsUpdatedOnEdit = true;
main.Estimate.NewCommand.Execute(null);
main.Estimate.Values.Add(new SampleViewModel() { Value = 1 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 2 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 3 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 4 });
main.Estimate.Values.Add(new SampleViewModel() { Value = 5 });
Assert.AreEqual(2.5, main.SelectedDistribution.Instance.Mean);
Assert.AreEqual(3.5, main.SelectedDistribution.Instance.Variance);
}
public void ConstructorTest_Rebind()
{
var main = new MainViewModel();
main.SetDistribution("Binomial");
main.GetParameter("Trials").Value = 2000;
main.GetParameter("Probability").Value = 0.063;
Assert.IsTrue(main.SelectedDistribution.Instance is BinomialDistribution);
var target = main.Analysis;
compute(target, 0, AnalysisViewModel.LessThan, 2);
compute(target, 0, AnalysisViewModel.LessThan, 53);
main.SetDistribution("Normal");
target = main.Analysis;
Assert.AreEqual(target.SelectedDistribution, main.SelectedDistribution);
Assert.IsTrue(main.SelectedDistribution.Instance is NormalDistribution);
}
public void ConstructorTest_NoncentralT()
{
var main = new MainViewModel();
main.SetDistribution("Noncentral T");
Assert.AreEqual(1, main.GetParameter("Degrees Of Freedom").Value);
Assert.AreEqual(0, main.GetParameter("Noncentrality").Value);
var target = main.Analysis;
var red = OxyColor.FromRgb(250, 0, 0);
var plot = target.DensityFunction;
var line = plot.Series[0] as LineSeries;
var area = plot.Series[1] as AreaSeries;
Assert.IsNotNull(line);
Assert.IsNotNull(area);
}
public void ConstructorTest_DiscreteColors()
{
var main = new MainViewModel();
main.SetDistribution("Binomial");
main.GetParameter("Trials").Value = 9;
main.GetParameter("Probability").Value = 0.5;
var target = main.Analysis;
Assert.AreEqual(main.SelectedDistribution, target.SelectedDistribution);
var red = OxyColor.FromRgb(250, 0, 0);
PlotModel plot;
ColumnSeries series;
compute(target, 0, AnalysisViewModel.LessThan, 3);
plot = target.DensityFunction;
series = plot.Series[0] as ColumnSeries;
Assert.AreEqual(1, plot.Series.Count);
Assert.AreEqual(8, series.Items.Count);
Assert.AreEqual(red, series.Items[0].Color);
Assert.AreEqual(red, series.Items[1].Color);
Assert.AreEqual(red, series.Items[2].Color);
Assert.AreNotEqual(red, series.Items[3].Color);
Assert.AreNotEqual(red, series.Items[4].Color);
Assert.AreNotEqual(red, series.Items[5].Color);
Assert.AreNotEqual(red, series.Items[6].Color);
Assert.AreNotEqual(red, series.Items[7].Color);
compute(target, 0, AnalysisViewModel.LessThan, 4);
plot = target.DensityFunction;
series = plot.Series[0] as ColumnSeries;
Assert.AreEqual(1, plot.Series.Count);
Assert.AreEqual(8, series.Items.Count);
Assert.AreEqual(red, series.Items[0].Color);
Assert.AreEqual(red, series.Items[1].Color);
Assert.AreEqual(red, series.Items[2].Color);
Assert.AreEqual(red, series.Items[3].Color);
Assert.AreNotEqual(red, series.Items[4].Color);
Assert.AreNotEqual(red, series.Items[5].Color);
Assert.AreNotEqual(red, series.Items[6].Color);
Assert.AreNotEqual(red, series.Items[7].Color);
compute(target, 0, AnalysisViewModel.LessThan, 5);
plot = target.DensityFunction;
series = plot.Series[0] as ColumnSeries;
Assert.AreEqual(1, plot.Series.Count);
Assert.AreEqual(8, series.Items.Count);
Assert.AreEqual(red, series.Items[0].Color);
Assert.AreEqual(red, series.Items[1].Color);
Assert.AreEqual(red, series.Items[2].Color);
Assert.AreEqual(red, series.Items[3].Color);
Assert.AreEqual(red, series.Items[4].Color);
Assert.AreNotEqual(red, series.Items[5].Color);
Assert.AreNotEqual(red, series.Items[6].Color);
Assert.AreNotEqual(red, series.Items[7].Color);
}
public void ConstructorTest_Example10d()
{
var main = new MainViewModel();
main.SetDistribution("Normal");
main.GetParameter("Mean").Value = 37;
main.GetParameter("Std. Dev.").Value = 0.4;
var target = main.Analysis;
compute(target, 0, AnalysisViewModel.LessThan, 35.8);
Assert.AreEqual(0.001349, target.Probability, 5e-5);
compute(target, 0, AnalysisViewModel.GreaterThan, 36.2);
Assert.AreEqual(0.977249, target.Probability, 5e-5);
compute(target, 35.8, AnalysisViewModel.Outside, 36.2);
Assert.AreEqual(0.978599, target.Probability, 5e-6);
}
/// <summary>
/// Attempts to create a new DistributionViewModel from a given type.
/// </summary>
public static bool TryParse(MainViewModel owner, Type type, Dictionary<string, DocumentationViewModel> doc, out DistributionViewModel distribution)
{
distribution = new DistributionViewModel(owner);
if (!typeof(IUnivariateDistribution).IsAssignableFrom(type) || !doc.ContainsKey(type.Name))
return false;
string name = DistributionManager.GetDistributionName(type);
// Extract all properties with return value of double
//
var properties = new List<PropertyViewModel>();
foreach (PropertyInfo prop in type.GetProperties())
{
PropertyViewModel property;
if (PropertyViewModel.TryParse(prop, distribution, out property))
properties.Add(property);
}
// Extract buildable constructors. A constructor is
// considered buildable if we can extract valid ranges
// and default values from all of its parameters
//
var list = new List<ConstructorViewModel>();
foreach (var ctor in type.GetConstructors())
{
ConstructorViewModel constructor;
if (ConstructorViewModel.TryParse(ctor, distribution, out constructor))
list.Add(constructor);
}
if (list.Count == 0)
return false;
// For the time being, just consider the buildable
// constructor with the largest number of parameters.
//
var main = list.OrderByDescending(x => x.Parameters.Count).First();
// Extract some documentation
var documentation = doc[type.Name];
documentation.Name = name;
distribution.Constructor = main;
distribution.Properties = new ObservableCollection<PropertyViewModel>(properties);
distribution.Parameters = main.Parameters;
distribution.Type = type;
distribution.Name = name;
distribution.Documentation = documentation;
foreach (var parameter in distribution.Constructor.Parameters)
parameter.ValueChanged += distribution.distribution_OnParameterChanged;
distribution.Options = DistributionManager.GetFittingOptions(distribution.Type);
return true;
}
public void ConstructorTest_Example04()
{
var main = new MainViewModel();
main.SetDistribution("Binomial");
main.GetParameter("Trials").Value = 3;
main.GetParameter("Probability").Value = 0.02;
AnalysisViewModel target = main.Analysis;
Assert.IsNotNull(target);
compute(target, 0, AnalysisViewModel.EqualTo, 3);
Assert.AreEqual(0.000008, target.Probability, 1e-10);
}
/// <summary>
/// Initializes a new instance of the <see cref="EstimateViewModel"/> class.
/// </summary>
///
public EstimateViewModel(MainViewModel owner)
{
this.Owner = owner;
this.Values = new BindingList<SampleViewModel>();
this.Values.ListChanged += data_ListChanged;
this.Values.Add(new SampleViewModel() { Value = 0, Weight = 1 });
this.Analysis = new ObservableCollection<GoodnessOfFitViewModel>();
this.NumberOfSamplesToBeGenerated = 100;
this.IsUpdatedOnEdit = false;
this.NewCommand = new RelayCommand(New_Execute);
this.SaveCommand = new RelayCommand(Save_Execute, Save_CanExecute);
this.OpenCommand = new RelayCommand(Open_Execute);
this.EstimateCommand = new RelayCommand(Estimate_Execute, Estimate_CanExecute);
this.GenerateCommand = new RelayCommand(generate_Execute);
CommandBindings.Add(new CommandBinding(ApplicationCommands.Paste,
(sender, e) => Paste_Executed(sender), Paste_CanExecute));
}
public void GompertzTest()
{
var main = new MainViewModel();
main.SetDistribution("Gompertz");
Assert.AreEqual(1, main.Estimate.Values.Count);
Assert.IsTrue(String.IsNullOrEmpty(main.Estimate.Message));
// Generate samples
Assert.AreEqual(1000, main.Estimate.NumberOfSamplesToBeGenerated);
main.Estimate.GenerateCommand.Execute(null);
Assert.AreEqual(1000, main.Estimate.Values.Count);
Assert.IsFalse(main.Estimate.Owner.SelectedDistribution.IsFittable);
Assert.IsFalse(String.IsNullOrEmpty(main.Estimate.Message));
}
public void ConstructorTest_Example10a()
{
var main = new MainViewModel();
main.SetDistribution("Normal");
main.GetParameter("Mean").Value = 36;
main.GetParameter("Std. Dev.").Value = 0.1;
AnalysisViewModel target = main.Analysis;
Assert.IsNotNull(target);
compute(target, 0, AnalysisViewModel.LessThan, 35.8);
Assert.AreEqual(0.0228, target.Probability, 5e-5);
compute(target, 0, AnalysisViewModel.GreaterThan, 36.2);
Assert.AreEqual(1.0 - 0.9772, target.Probability, 5e-5);
compute(target, 35.8, AnalysisViewModel.Outside, 36.2);
Assert.AreEqual(0.0455002, target.Probability, 5e-6);
}
/// <summary>
/// Initializes a new instance of the <see cref="DistributionViewModel"/> class.
/// </summary>
///
public DistributionViewModel(MainViewModel owner)
{
this.Owner = owner;
this.Parameters = new ObservableCollection<ParameterViewModel>();
this.Properties = new ObservableCollection<PropertyViewModel>();
this.Measures = new MeasuresViewModel();
}