private void MakeMalformation(Phenomenon index, CurvesDataManager data, int curveIndex)
{
const int Y_VALUES_INDEX = 0;
Series series = data.ModifiedCurves[curveIndex];
int pointsNo = series.Points.Count;
double valuesInterval = SeriesAssist.GetValuesInterval(series, Y_VALUES_INDEX);
switch (index)
{
case Phenomenon.Peek:
SeriesAssist.OverrideValue(series, Convert.ToInt32((1.0 / 4.0) * pointsNo), -(1.0 / 2.0) * valuesInterval, Y_VALUES_INDEX);
SeriesAssist.OverrideValue(series, Convert.ToInt32((1.0 / 3.0) * pointsNo), (1.0 / 5.0) * valuesInterval, Y_VALUES_INDEX);
SeriesAssist.OverrideValue(series, Convert.ToInt32((1.0 / 2.0) * pointsNo), (1.0 / 2.0) * valuesInterval, Y_VALUES_INDEX);
SeriesAssist.OverrideValue(series, Convert.ToInt32((2.0 / 3.0) * pointsNo), -(1.0 / 5.0) * valuesInterval, Y_VALUES_INDEX);
SeriesAssist.OverrideValue(series, Convert.ToInt32((3.0 / 4.0) * pointsNo), (1.0 / 2.0) * valuesInterval, Y_VALUES_INDEX);
break;
case Phenomenon.Saturation:
int leftPoint = Convert.ToInt32((4.0 / 11.0) * pointsNo);
int rightPoint = Convert.ToInt32((8.0 / 11.0) * pointsNo);
SeriesAssist.OverrideValues(series, leftPoint, rightPoint, (3.0 / 11.0) * valuesInterval, Y_VALUES_INDEX);
break;
}
data.AlterCurve(series, DataSetCurveType.Modified, curveIndex);
}
private void OnApplyClick(object sender, EventArgs e)
{
if (DataChart.IdealCurve.Points.Count == 0)
{
log.Info(MethodBase.GetCurrentMethod().Name + '(' + nameof(DataChart.IdealCurve) + ')');
AppMessages.MainWindow.ExclamationOfSeriesSelection();
return;
}
MeanType meanType = (MeanType)UiControls.TryGetSelectedIndex(uiPnlAvg_MeanT_ComBx);
int curvesNo = UiControls.TryGetValue <int>(uiPnlAvg_Crvs2No_Num);
bool? result = DataChart.TryMakeAverageCurve(meanType, curvesNo);
log.Info(MethodBase.GetCurrentMethod().Name + '(' + meanType + ',' + curvesNo + ',' + result.HasValue + ')');
if (!result.Value)
{
DataChart.RemoveInvalidPoints(DataSetCurveType.Average);
AppMessages.MainWindow.ExclamationOfPointsNotValidToChart();
}
UiControls.TrySetSelectedIndex(uiPnlMod_CrvT_ComBx, (int)DataSetCurveType.Average);
UpdateUiByShowingCurveOnChart(DataSetCurveType.Average);
double standardDeviation = Mathematics.GetRelativeStandardDeviation(SeriesAssist.GetValues(DataChart.AverageCurve), SeriesAssist.GetValues(DataChart.IdealCurve));
uiPnlAvg_StdDev2_TxtBx.Text = Strings.TryFormatAsNumeric(8, standardDeviation);
}
private void CalculateStandardDeviations()
{
int meanTypes = new MeanTypesStrings().Count();
double stdDeviation;
IList <double> averagesValues;
IList <double> idealValues;
for (int i = 0; i < Data.Count; i++)
{
for (int j = 0; j < Noises.Count; j++)
{
Data[i][j].GenerateIdealCurve(Settings.Pcd.Scaffold, Settings.Pcd.Parameters, Settings.Ui.StartX, Settings.Ui.EndX, Settings.Ui.PointsNo);
Data[i][j].PropagateIdealCurve(Settings.Ui.CurvesNo);
Data[i][j].MakeNoiseOfGaussian(Settings.Ui.CurvesNo, Noises[j]);
MakeMalformation((Phenomenon)i, Data[i][j], Settings.Ui.CurvesNo / 2);
for (int k = 0; k < meanTypes; k++)
{
Data[i][j].TryMakeAverageCurve((MeanType)k, Settings.Ui.CurvesNo);
SeriesAssist.CopyPoints(Data[i][j].AverageCurve, Averages[i][j][k]);
averagesValues = SeriesAssist.GetValues(Averages[i][j][k]);
idealValues = SeriesAssist.GetValues(Data[i][j].IdealCurve);
stdDeviation = Mathematics.GetRelativeStandardDeviation(averagesValues, idealValues);
StdDeviations[i][j][k] = stdDeviation;
}
}
}
}
public void Alter5()
{
// given
Series series = TestObjects.GetSeries();
// when
SeriesAssist.Alter(Operation.Constant, 0.0, series, 2, 1, 0);
}
public GridPreviewer(Series series)
{
InitializeComponent();
Curve = series;
Originals = SeriesAssist.GetValues(series);
LocalizeWindow();
UpdateUiBySettings();
}
public void Alter7()
{
// given
Series series = TestObjects.GetSeries();
const double OPERAND = 123.0;
// when
SeriesAssist.Alter(Operation.Exponentiation, OPERAND, series, 0, series.Points.Count - 1);
}
private void UpdateUiByPopulatingGrid()
{
GridAssist.AlterColumnHeader(Index, new GridPreviewerStrings().Ui.DatasetIndex.GetString());
GridAssist.AlterColumnHeader(x, "x");
GridAssist.AlterColumnHeader(y, "y", false);
GridAssist.AddRows(uiGrid_db_grid, Curve.Points.Count);
GridAssist.PopulateColumn(uiGrid_db_grid, Index.Name, Lists.GetOrdinalValues(0, Convert.ToUInt64(Curve.Points.Count)));
GridAssist.PopulateColumn(uiGrid_db_grid, x.Name, SeriesAssist.GetArguments(Curve), 4);
GridAssist.PopulateColumn(uiGrid_db_grid, y.Name, SeriesAssist.GetValues(Curve), VALUES_DECIMAL_PLACES);
}
private void OnResetClick(object sender, EventArgs e)
{
Series copy = SeriesAssist.GetCopy(Curve);
Curve.Points.Clear();
SeriesAssist.CopyPoints(Curve, copy, Originals);
GridAssist.PopulateColumn(uiGrid_db_grid, y.Name, SeriesAssist.GetValues(Curve), VALUES_DECIMAL_PLACES);
UpdateUiByRefreshingChart();
UpdateUiByPanelStateInfo(PanelStateInformation.ValuesRestored);
log.Info(MethodBase.GetCurrentMethod().Name + "()");
}
private void OnShowDataSetClick(object sender, EventArgs e)
{
DataSetCurveType curveType = (DataSetCurveType)UiControls.TryGetSelectedIndex(uiPnlMod_CrvT_ComBx);
int curveIndex = UiControls.TryGetValue <int>(uiPnlMod_CrvIdx_Num);
string signature = MethodBase.GetCurrentMethod().Name + '(' + curveType + ',' + curveIndex + ')';
switch (curveType)
{
case DataSetCurveType.Ideal:
case DataSetCurveType.Modified:
case DataSetCurveType.Average:
break;
default:
log.Info(signature);
AppMessages.MainWindow.AsteriskOfCurveTypeNotSelected();
return;
}
Series curveSeries = SpecifyCurveSeries(curveType, curveIndex);
if (curveSeries == null || curveSeries.Points.Count == 0)
{
log.Info(MethodBase.GetCurrentMethod().Name + '(' + nameof(curveSeries) + ')');
AppMessages.MainWindow.ExclamationOfSeriesSelection();
return;
}
using (var dialog = new GridPreviewer(SeriesAssist.GetCopy(curveSeries))) {
dialog.Height = Settings.Dimensions.GridPreviewer.Height;
dialog.Width = Settings.Dimensions.GridPreviewer.Width;
UiControls.TryShowDialog(dialog, this);
try {
if (dialog.DialogResult == DialogResult.OK)
{
DataChart.AlterCurve(dialog.Curve, curveType, curveIndex);
ChartAssist.Refresh(dialog.Curve, Color.Indigo, uiCharts_Crv);
}
}
catch (InvalidOperationException ex) {
log.Error(signature, ex);
AppMessages.MainWindow.ErrorOfChartRefreshing();
}
catch (Exception ex) {
log.Fatal(signature, ex);
}
}
log.Info(signature);
}
private void OnSaveClick(object sender, EventArgs e)
{
IList <double> values = Lists.Cast <object, double>(GridAssist.GetColumnValues(uiGrid_db_grid, y.HeaderText));
if (!SeriesAssist.IsChartAcceptable(values))
{
log.Info(MethodBase.GetCurrentMethod().Name + '(' + PanelStateInformation.OperationRevoked + ')');
UpdateUiByPanelStateInfo(PanelStateInformation.OperationRevoked);
AppMessages.GridPreviewer.ErrorOfInvalidCurvePoints();
return;
}
SeriesAssist.OverrideValues(Curve, values);
UpdateUiByPanelStateInfo(PanelStateInformation.ChangesSaved);
log.Info(MethodBase.GetCurrentMethod().Name + '(' + PanelStateInformation.ChangesSaved + ')');
}
public void GetCopy1()
{
// given
Series series1 = TestObjects.GetSeries();
Series series2 = TestObjects.GetSeries(new List <double>()
{
-1, 0, 1
});
// when
Series result1 = SeriesAssist.GetCopy(series1, 0, false);
Series result2 = SeriesAssist.GetCopy(series2);
// then
Assertions.SameValues(series1, result1);
Assertions.SameValues(series2, result2);
}
private void OnPerformClick(object sender, EventArgs e)
{
Operation @operator = (Operation)UiControls.TryGetSelectedIndex(uiPnl_OperT_ComBx);
double? userValue = (@operator == Operation.Positive || @operator == Operation.Negative) ? default(double) : Strings.TryGetValue(uiPnl_Val2_TxtBx.Text);
if (userValue == null || Curve == null)
{
log.Info(MethodBase.GetCurrentMethod().Name + '(' + userValue + ',' + Curve + ')');
UpdateUiByPanelStateInfo(PanelStateInformation.InvalidUserValue);
AppMessages.GridPreviewer.ExclamationOfImproperUserValue();
return;
}
int startIndex = UiControls.TryGetValue <int>(uiPnl_StartIdx_Num);
int endIndex = UiControls.TryGetValue <int>(uiPnl_EndIdx_Num);
Series seriesCopy = SeriesAssist.GetCopy(Curve);
Operation operation = (Operation)uiPnl_OperT_ComBx.SelectedIndex;
string signature = string.Empty;
try {
signature = MethodBase.GetCurrentMethod().Name + '(' + startIndex + ',' + endIndex + ',' + operation + ',' + userValue.Value + ')';
SeriesAssist.Alter(operation, userValue.Value, seriesCopy, startIndex, endIndex);
}
catch (NotFiniteNumberException ex) {
log.Error(signature, ex);
UpdateUiByPanelStateInfo(PanelStateInformation.OperationRevoked);
AppMessages.GridPreviewer.ErrorOfInvalidCurvePoints();
return;
}
catch (Exception ex) {
log.Fatal(signature, ex);
UpdateUiByPanelStateInfo(PanelStateInformation.OperationRejected);
AppMessages.GridPreviewer.ErrorOfPerformOperation();
return;
}
Curve.Points.Clear();
SeriesAssist.CopyPoints(seriesCopy, Curve);
GridAssist.PopulateColumn(uiGrid_db_grid, y.Name, SeriesAssist.GetValues(Curve), VALUES_DECIMAL_PLACES);
UpdateUiByRefreshingChart();
UpdateUiByPanelStateInfo(PanelStateInformation.PerformedAndRefreshed);
log.Info(signature);
}
internal StatisticalAnalysis(GeneratorSettings genSets)
{
InitializeComponent();
Settings = genSets;
Noises = new List <double>()
{
0.1, 0.5, 1.0, 11.0
};
int dimension1 = Enum.GetValues(typeof(Phenomenon)).Length;
int dimension2 = Noises.Count;
int dimension3 = Enum.GetValues(typeof(MeanType)).Length;
Data = Lists.GetCloneable(dimension1, dimension2, new CurvesDataManager());
Averages = Lists.GetNew <Series>(dimension1, dimension2, dimension3);
Averages.ToList().ForEach(l2 => l2.ToList().ForEach(l1 => l1.ToList().ForEach(s => SeriesAssist.SetDefaultSettings(s))));
StdDeviations = Lists.GetNew <double>(dimension1, dimension2, dimension3);
UpdateUiByGridPresentation();
UpdateUiBySettings();
CalculateStandardDeviations();
UpdateUiByPopulatingStandardDeviationsOnGrid();
UpdateUiByColoringGridsExtremums();
LocalizeWindow();
}
public void Alter1()
{
// given
const int START_INDEX = 1;
const int END_INDEX = 3;
IList <double> set = new List <double>()
{
1, 2, 3, 4, 5
};
Series series1 = TestObjects.GetSeries(set);
Series series2 = TestObjects.GetSeries(set);
Series series3 = TestObjects.GetSeries(set);
Series series4 = TestObjects.GetSeries(set);
Series series5 = TestObjects.GetSeries(set);
Series series6 = TestObjects.GetSeries(set);
Series series7 = TestObjects.GetSeries(set);
Series series8 = TestObjects.GetSeries(set);
Series series9 = TestObjects.GetSeries(set);
Series series10 = TestObjects.GetSeries(set);
double operand1 = Math.Sqrt(2.0);
double operand2 = Math.Sqrt(3.1);
double operand3 = Math.Sqrt(Math.PI);
double operand4 = Math.Sqrt(2.0 * Math.PI);
double operand5 = Math.Sqrt(Math.Cos(0.5));
double operand6 = Math.Log10(10.123);
double operand7 = Mathematics.Root(8.0, Math.Sqrt(2.0));
double operand8 = Mathematics.Reciprocal(Mathematics.Root(8.0, 2.0));
IList <double> expected1 = new List <double>()
{
set[0], set[1] + operand1, set[2] + operand1, set[3] + operand1, set[4]
};
IList <double> expected2 = new List <double>()
{
set[0], set[1] - operand2, set[2] - operand2, set[3] - operand2, set[4]
};
IList <double> expected3 = new List <double>()
{
set[0], set[1] * operand3, set[2] * operand3, set[3] * operand3, set[4]
};
IList <double> expected4 = new List <double>()
{
set[0], set[1] / operand4, set[2] / operand4, set[3] / operand4, set[4]
};
IList <double> expected5 = new List <double>()
{
set[0], Math.Pow(set[1], operand5), Math.Pow(set[2], operand5), Math.Pow(set[3], operand5), set[4]
};
IList <double> expected6 = new List <double>()
{
set[0], Math.Log(set[1], operand6), Math.Log(set[2], operand6), Math.Log(set[3], operand6), set[4]
};
IList <double> expected7 = new List <double>()
{
set[0], Mathematics.Root(set[1], operand7), Mathematics.Root(set[2], operand7), Mathematics.Root(set[3], operand7), set[4]
};
IList <double> expected8 = new List <double>()
{
set[0], operand8, operand8, operand8, set[4]
};
IList <double> expected10 = new List <double>()
{
set[0], -Math.Abs(set[1]), -Math.Abs(set[2]), -Math.Abs(set[3]), set[4]
};
// when
SeriesAssist.Alter(Operation.Addition, operand1, series1, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Subtraction, operand2, series2, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Multiplication, operand3, series3, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Division, operand4, series4, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Exponentiation, operand5, series5, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Logarithmic, operand6, series6, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Rooting, operand7, series7, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Constant, operand8, series8, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Positive, 0.0, series9, START_INDEX, END_INDEX);
SeriesAssist.Alter(Operation.Negative, 0.0, series10, START_INDEX, END_INDEX);
// then
Assertions.SameValues(expected1, series1);
Assertions.SameValues(expected2, series2);
Assertions.SameValues(expected3, series3);
Assertions.SameValues(expected4, series4);
Assertions.SameValues(expected5, series5);
Assertions.SameValues(expected6, series6);
Assertions.SameValues(expected7, series7);
Assertions.SameValues(expected8, series8);
Assertions.SameValues(set, series9);
Assertions.SameValues(expected10, series10);
}
public void Alter6()
{
// when
SeriesAssist.Alter(Operation.Constant, 0.0, null, 0, 0, 0);
}
