Пример #1
0
        public void ExponentialSmoothing()
        {
            SelectAnalyzedVariable dlg = new SelectAnalyzedVariable(this.data.SeriesVariables);
            dlg.ShowDialog();
            if (dlg.DialogResult == DialogResult.OK)
            {
                ExponentialSmoothingForm esForm = new ExponentialSmoothingForm();
                esForm.SetVariable(dlg.SelectedVariable);
                esForm.ShowDialog();
                if (esForm.DialogResult == DialogResult.Yes)
                {

                    if (esForm.IsStoreSmoothed)
                    {
                        SeriesVariable var = new SeriesVariable(esForm.SmoothedName, "Smoothed Value of exponential smoothing of variable '"
                            + dlg.SelectedVariable.VariableName + "'");
                        int lag = dlg.SelectedVariable.SeriesValues.Count - esForm.EsTable.predicted.Length;
                        var.InitializeItem(dlg.SelectedVariable.SeriesValues.Count);
                        for (int i = 0; i < lag; i++) var[i] = double.NaN;
                        for (int i = 0; i < esForm.EsTable.smoothed.Length; i++) var[i + lag] = esForm.EsTable.smoothed[i];
                        this.data.SeriesVariables.Add(var);
                        this.seriesDataList.Refresh();
                    }

                    if (esForm.IsStorePredicted)
                    {
                        SeriesVariable var = new SeriesVariable(esForm.PredictedName, "Predicted Value of exponential smoothing of variable '"
                            + dlg.SelectedVariable.VariableName + "'");
                        int lag = dlg.SelectedVariable.SeriesValues.Count - esForm.EsTable.predicted.Length;
                        var.InitializeItem(dlg.SelectedVariable.SeriesValues.Count);
                        for (int i = 0; i < lag; i++) var[i] = double.NaN;
                        for (int i = 0; i < esForm.EsTable.predicted.Length; i++) var[i + lag] = esForm.EsTable.predicted[i];
                        this.data.SeriesVariables.Add(var);
                        this.seriesDataList.Refresh();
                    }

                    if (esForm.IsStoreResidual)
                    {
                        SeriesVariable var = new SeriesVariable(esForm.ResidualName, "Residual Value of exponential smoothing of variable '"
                            + dlg.SelectedVariable.VariableName + "'");
                        int lag = dlg.SelectedVariable.SeriesValues.Count - esForm.EsTable.residual.Length;
                        var.InitializeItem(dlg.SelectedVariable.SeriesValues.Count);
                        for (int i = 0; i < lag; i++) var[i] = double.NaN;
                        for (int i = 0; i < esForm.EsTable.residual.Length; i++) var[i + lag] = esForm.EsTable.residual[i];
                        this.data.SeriesVariables.Add(var);
                        this.seriesDataList.Refresh();
                    }

                    ESResultTabPage esTabPage = new ESResultTabPage();

                    if (esForm.EsProperties.initialModel == 1)
                        esTabPage.Title = "Single ES : '" + dlg.SelectedVariable.VariableName + "'";
                    if (esForm.EsProperties.initialModel == 2)
                        esTabPage.Title = "Double ES (Brown) : '" + dlg.SelectedVariable.VariableName + "'";
                    if (esForm.EsProperties.initialModel == 3)
                        esTabPage.Title = "Double ES (Holt) : '" + dlg.SelectedVariable.VariableName + "'";
                    if (esForm.EsProperties.initialModel == 4)
                        esTabPage.Title = "Triple ES (Winter) : '" + dlg.SelectedVariable.VariableName + "'";

                    if (esForm.IsForecastedDataGridChecked)
                    {
                        if (esForm.EsProperties.initialModel == 1)
                        {
                            esTabPage.SetData(this.data, dlg.SelectedVariable, esForm.EsProperties,
                                esForm.EsTable, esForm.SesForecast(esForm.ForecastingStep));
                        }
                        if (esForm.EsProperties.initialModel == 2)
                        {
                            esTabPage.SetData(this.data, dlg.SelectedVariable, esForm.EsProperties,
                                esForm.EsTable, esForm.BrownForecast(esForm.ForecastingStep));
                        }
                        if (esForm.EsProperties.initialModel == 3)
                        {
                            esTabPage.SetData(this.data, dlg.SelectedVariable, esForm.EsProperties,
                                esForm.EsTable, esForm.HoltForecast(esForm.ForecastingStep));
                        }
                        if (esForm.EsProperties.initialModel == 4)
                        {
                            esTabPage.SetData(this.data, dlg.SelectedVariable, esForm.EsProperties,
                                esForm.EsTable, esForm.WinterForecast(esForm.ForecastingStep));
                        }
                    }

                    else
                    {
                        esTabPage.SetData(this.data, dlg.SelectedVariable, esForm.EsProperties,
                            esForm.EsTable, null);
                    }
                    esTabPage.IsEsModelSummaryVisible = esForm.IsEsModelSummaryChecked;

                    esTabPage.IsExponentialSmoothingDataGridVisible = esForm.IsExponentialSmoothingDataGridChecked;
                    esTabPage.IsSmoothingVisible = esForm.IsSmoothingChecked;
                    esTabPage.IsTrendVisible = esForm.IsTrendChecked;
                    esTabPage.IsSeasonalVisible = esForm.IsSeasonalChecked;
                    esTabPage.IsForecastedDataGridVisible = esForm.IsForecastedDataGridChecked;
                    esTabPage.IsActualAndPredictedGraphVisible = esForm.IsActualAndPredictedGraphChecked;
                    esTabPage.IsActualAndSmoothedGraphVisible = esForm.IsActualAndSmoothedGraphChecked;
                    esTabPage.IsActualAndForecastedGraphVisible = esForm.IsActualAndForecastedGraphChecked;
                    esTabPage.IsActualVsPredictedGraphVisible = esForm.IsActualVsPredictedGraphChecked;
                    esTabPage.IsResidualGraphVisible = esForm.IsResidualGraphChecked;
                    esTabPage.IsResidualVsActualGraphVisible = esForm.IsResidualVsActualGraphChecked;
                    esTabPage.IsResidualVsPredictedGraphVisible = esForm.IsResidualVsPredictedGraphChecked;

                    esTabPage.DrawControl();

                    esTabPage.IsDrawn = true;
                    this.tabControlResult.AddTab(esTabPage);
                    this.tabControlResult.SelectedItem = esTabPage;

                    this.tabControlData.SelectedTab = this.tabPageResult;

                }
            }
        }
        /// <summary>
        /// Membaca hasil pada Result View
        /// </summary>
        /// <param name="data">Series Data rujukan</param>
        /// <returns>Tab Page yang akan ditampilkan pada Result View</returns>
        public List<FATabStripItem> ReadResultPane(SeriesData data)
        {
            List<FATabStripItem> result = new List<FATabStripItem>();
            string tmpString;

            seriesDataReader.ReadToFollowing("ResultPane");
            seriesDataReader.ReadStartElement();

            while (seriesDataReader.IsStartElement("TabPage"))
            {
                seriesDataReader.ReadStartElement();
                tmpString = seriesDataReader.ReadElementContentAsString();
                if (tmpString == "Neural Network")
                {
                    ANNResultTabPage annTp = new ANNResultTabPage();
                    string title = seriesDataReader.ReadElementContentAsString();
                    tmpString = seriesDataReader.ReadElementContentAsString();
                    int index = VariableFinder.FindVariableIndex(data.SeriesVariables, tmpString);

                    NeuralNetworkAnalysisForm.NetworkSpecification tmpNetSpec = new NeuralNetworkAnalysisForm.NetworkSpecification();
                    seriesDataReader.ReadStartElement();
                    tmpNetSpec.InputLayerNeurons = seriesDataReader.ReadElementContentAsInt();
                    tmpNetSpec.HiddenLayerNeurons = seriesDataReader.ReadElementContentAsInt();
                    tmpNetSpec.OutputLayerNeurons = seriesDataReader.ReadElementContentAsInt();
                    tmpNetSpec.ActivationFunction = (NeuralNetworkAnalysisForm.ActivationFunctionEnumeration)seriesDataReader.ReadElementContentAsInt();
                    tmpNetSpec.LearningRate = seriesDataReader.ReadElementContentAsDouble();
                    tmpNetSpec.Momentum = seriesDataReader.ReadElementContentAsDouble();
                    tmpNetSpec.IncludedObservations = seriesDataReader.ReadElementContentAsInt();
                    tmpNetSpec.Error = seriesDataReader.ReadElementContentAsDouble();
                    tmpNetSpec.MSE = seriesDataReader.ReadElementContentAsDouble();
                    tmpNetSpec.MAE = seriesDataReader.ReadElementContentAsDouble();
                    seriesDataReader.ReadEndElement();

                    List<double> tmpPredicted = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpPredicted.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();

                    List<double> tmpForecasted = new List<double>();
                    if (seriesDataReader.IsStartElement("Forecasted"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpForecasted.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                    }

                    annTp.SetData(data, data.SeriesVariables[index], tmpNetSpec, tmpPredicted.ToArray(), tmpForecasted.ToArray());

                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("View"))
                    {
                        tmpString = seriesDataReader.ReadElementContentAsString();
                        if (tmpString == "AnnModelSummary") annTp.IsAnnModelSummaryVisible = true;
                        else if (tmpString == "ActualPredictedResidualDataGrid") annTp.IsActualPredictedResidualDataGridVisible = true;
                        else if (tmpString == "ForecastedDataGrid") annTp.IsForecastedDataGridVisible = true;
                        else if (tmpString == "ActualAndPredictedGraph") annTp.IsActualAndPredictedGraphVisible = true;
                        else if (tmpString == "ActualAndForecastedGraph") annTp.IsActualAndForecastedGraphVisible = true;
                        else if (tmpString == "ActualVsPredictedGraph") annTp.IsActualVsPredictedGraphVisible = true;
                        else if (tmpString == "ResidualGraph") annTp.IsResidualGraphVisible = true;
                        else if (tmpString == "ResidualVsActualGraph") annTp.IsResidualVsActualGraphVisible = true;
                        else if (tmpString == "ResidualVsPredictedGraph") annTp.IsResidualVsPredictedGraphVisible = true;
                    }
                    seriesDataReader.ReadEndElement();

                    annTp.Title = title;
                    annTp.DrawControl();
                    result.Add(annTp);
                    seriesDataReader.ReadEndElement();
                }
                else if (tmpString == "Moving Average")
                {
                    MAResultTabPage maTp = new MAResultTabPage();
                    string title = seriesDataReader.ReadElementContentAsString();
                    tmpString = seriesDataReader.ReadElementContentAsString();
                    int index = VariableFinder.FindVariableIndex(data.SeriesVariables, tmpString);

                    MovingAverageForm.MASpecification tmpMaSpec = new MovingAverageForm.MASpecification();
                    seriesDataReader.ReadStartElement();
                    tmpMaSpec.includedObservations = seriesDataReader.ReadElementContentAsInt();
                    tmpMaSpec.isSingleMA = seriesDataReader.ReadElementContentAsBoolean();
                    tmpMaSpec.orde = seriesDataReader.ReadElementContentAsInt();
                    tmpMaSpec.sseMA = seriesDataReader.ReadElementContentAsDouble();
                    tmpMaSpec.mseMA = seriesDataReader.ReadElementContentAsDouble();
                    tmpMaSpec.maeMA = seriesDataReader.ReadElementContentAsDouble();
                    tmpMaSpec.mpeMA = seriesDataReader.ReadElementContentAsDouble();
                    tmpMaSpec.mapeMA = seriesDataReader.ReadElementContentAsDouble();
                    seriesDataReader.ReadEndElement();

                    MovingAverageForm.MAComponent tmpMaComp = new MovingAverageForm.MAComponent();

                    List<double> tmpSingleMA = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpSingleMA.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpMaComp.singleSmoothed = tmpSingleMA.ToArray();

                    List<double> tmpDoubleMA = new List<double>();
                    if (seriesDataReader.IsStartElement("DoubleMA"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpDoubleMA.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                     tmpMaComp.doubleSmoothed = tmpDoubleMA.ToArray();
                    }

                    List<double> tmpPredicted = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpPredicted.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpMaComp.predicted = tmpPredicted.ToArray();

                    List<double> tmpResidual = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpResidual.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpMaComp.residual = tmpResidual.ToArray();

                    List<double> tmpForecasted = new List<double>();
                    if (seriesDataReader.IsStartElement("Forecasted"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpForecasted.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                    }

                    maTp.SetData(data, data.SeriesVariables[index], tmpMaSpec, tmpMaComp, tmpForecasted.ToArray());

                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("View"))
                    {
                        tmpString = seriesDataReader.ReadElementContentAsString();
                        if (tmpString == "MAModelSummary") maTp.IsMaModelSummaryVisible = true;
                        else if (tmpString == "MovingAverageDataGrid") maTp.IsMovingAverageDataGridVisible = true;
                        else if (tmpString == "Smoothing") maTp.IsSmoothingVisible = true;
                        //else if (tmpString == "ActualPredictedResidualDataGrid") maTp.IsActualPredictedResidualDataGridVisible = true;
                        else if (tmpString == "ForecastedDataGrid") maTp.IsForecastedDataGridVisible = true;
                        else if (tmpString == "ActualAndPredictedGraph") maTp.IsActualAndPredictedGraphVisible = true;
                        else if (tmpString == "ActualAndSmoothedGraph") maTp.IsActualAndSmoothedGraphVisible = true;
                        else if (tmpString == "ActualAndForecastedGraph") maTp.IsActualAndForecastedGraphVisible = true;
                        else if (tmpString == "ActualVsPredictedGraph") maTp.IsActualVsPredictedGraphVisible = true;
                        else if (tmpString == "ResidualGraph") maTp.IsResidualGraphVisible = true;
                        else if (tmpString == "ResidualVsActualGraph") maTp.IsResidualVsActualGraphVisible = true;
                        else if (tmpString == "ResidualVsPredictedGraph") maTp.IsResidualVsPredictedGraphVisible = true;
                    }
                    seriesDataReader.ReadEndElement();

                    maTp.Title = title;
                    maTp.DrawControl();
                    result.Add(maTp);
                    seriesDataReader.ReadEndElement();
                }
                else if (tmpString == "Exponential Smoothing")
                {
                    ESResultTabPage esTp = new ESResultTabPage();
                    string title = seriesDataReader.ReadElementContentAsString();
                    tmpString = seriesDataReader.ReadElementContentAsString();
                    int index = VariableFinder.FindVariableIndex(data.SeriesVariables, tmpString);

                    ExponentialSmoothingForm.ESSpecification tmpEsSpec = new ExponentialSmoothingForm.ESSpecification();
                    seriesDataReader.ReadStartElement();
                    tmpEsSpec.includedObservations = seriesDataReader.ReadElementContentAsInt();
                    tmpEsSpec.alpha = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.gamma = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.beta = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.seasonalLength = seriesDataReader.ReadElementContentAsInt();
                    tmpEsSpec.sseES = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.mseES = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.maeES = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.mpeES = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.mapeES = seriesDataReader.ReadElementContentAsDouble();
                    tmpEsSpec.initialModel = seriesDataReader.ReadElementContentAsInt();
                    tmpEsSpec.isMultiplicative = seriesDataReader.ReadElementContentAsBoolean();
                    seriesDataReader.ReadEndElement();

                    ExponentialSmoothingForm.ESComponent tmpEsComp = new ExponentialSmoothingForm.ESComponent();

                    List<double> tmpSmoothed = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpSmoothed.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpEsComp.smoothed = tmpSmoothed.ToArray();

                    List<double> tmpTrend = new List<double>();
                    if (seriesDataReader.IsStartElement("Trend"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpTrend.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                        tmpEsComp.trend = tmpTrend.ToArray();
                    }

                    List<double> tmpSeasonal = new List<double>();
                    if (seriesDataReader.IsStartElement("Seasonal"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpSeasonal.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                        tmpEsComp.seasonal = tmpSeasonal.ToArray();
                    }

                    List<double> tmpPredicted = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpPredicted.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpEsComp.predicted = tmpPredicted.ToArray();

                    List<double> tmpResidual = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpResidual.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpEsComp.residual = tmpResidual.ToArray();

                    List<double> tmpForecasted = new List<double>();
                    if (seriesDataReader.IsStartElement("Forecasted"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpForecasted.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                    }

                    esTp.SetData(data, data.SeriesVariables[index], tmpEsSpec, tmpEsComp, tmpForecasted.ToArray());

                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("View"))
                    {
                        tmpString = seriesDataReader.ReadElementContentAsString();
                        if (tmpString == "ESModelSummary") esTp.IsEsModelSummaryVisible = true;
                        else if (tmpString == "ExponentialSmoothingDataGrid") esTp.IsExponentialSmoothingDataGridVisible = true;
                        else if (tmpString == "Smoothing") esTp.IsSmoothingVisible = true;
                        else if (tmpString == "Trend") esTp.IsSmoothingVisible = true;
                        else if (tmpString == "Seasonal") esTp.IsSmoothingVisible = true;
                        //else if (tmpString == "ActualPredictedResidualDataGrid") maTp.IsActualPredictedResidualDataGridVisible = true;
                        else if (tmpString == "ForecastedDataGrid") esTp.IsForecastedDataGridVisible = true;
                        else if (tmpString == "ActualAndPredictedGraph") esTp.IsActualAndPredictedGraphVisible = true;
                        else if (tmpString == "ActualAndSmoothedGraph") esTp.IsActualAndSmoothedGraphVisible = true;
                        else if (tmpString == "ActualAndForecastedGraph") esTp.IsActualAndForecastedGraphVisible = true;
                        else if (tmpString == "ActualVsPredictedGraph") esTp.IsActualVsPredictedGraphVisible = true;
                        else if (tmpString == "ResidualGraph") esTp.IsResidualGraphVisible = true;
                        else if (tmpString == "ResidualVsActualGraph") esTp.IsResidualVsActualGraphVisible = true;
                        else if (tmpString == "ResidualVsPredictedGraph") esTp.IsResidualVsPredictedGraphVisible = true;
                    }
                    seriesDataReader.ReadEndElement();

                    esTp.Title = title;
                    esTp.DrawControl();
                    result.Add(esTp);
                    seriesDataReader.ReadEndElement();
                }
                else if (tmpString == "Decomposition")
                {
                    DECResultTabPage decTp = new DECResultTabPage();
                    string title = seriesDataReader.ReadElementContentAsString();
                    tmpString = seriesDataReader.ReadElementContentAsString();
                    int index = VariableFinder.FindVariableIndex(data.SeriesVariables, tmpString);

                    DecompositionForm.DECSpecification tmpDecSpec = new DecompositionForm.DECSpecification();
                    seriesDataReader.ReadStartElement();
                    tmpDecSpec.includedObservations = seriesDataReader.ReadElementContentAsInt();
                    tmpDecSpec.seasonalLength = seriesDataReader.ReadElementContentAsInt();
                    tmpDecSpec.sseDEC = seriesDataReader.ReadElementContentAsDouble();
                    tmpDecSpec.mseDEC = seriesDataReader.ReadElementContentAsDouble();
                    tmpDecSpec.maeDEC = seriesDataReader.ReadElementContentAsDouble();
                    tmpDecSpec.mpeDEC = seriesDataReader.ReadElementContentAsDouble();
                    tmpDecSpec.mapeDEC = seriesDataReader.ReadElementContentAsDouble();
                    tmpDecSpec.isMultiplikatif = seriesDataReader.ReadElementContentAsBoolean();
                    tmpDecSpec.initialTrend = seriesDataReader.ReadElementContentAsInt();
                    seriesDataReader.ReadEndElement();

                    List<double> tmpParameters = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpParameters.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecSpec.parameters = tmpParameters.ToArray();

                    List<double> tmpSeasonalIdx = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpSeasonalIdx.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecSpec.seasonalIdx = tmpSeasonalIdx.ToArray();

                    DecompositionForm.DECComponent tmpDecComp = new DecompositionForm.DECComponent();

                    List<double> tmpTrend = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpTrend.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecComp.trend = tmpTrend.ToArray();

                    List<double> tmpDetrend = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpDetrend.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecComp.detrend = tmpDetrend.ToArray();

                    List<double> tmpSeasonal = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpSeasonal.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecComp.seasonal = tmpSeasonal.ToArray();

                    List<double> tmpDeseasonal = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpDeseasonal.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecComp.deseasonal = tmpDeseasonal.ToArray();

                    List<double> tmpPredicted = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpPredicted.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecComp.predicted = tmpPredicted.ToArray();

                    List<double> tmpResidual = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpResidual.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpDecComp.residual = tmpResidual.ToArray();

                    List<double> tmpForecasted = new List<double>();
                    if (seriesDataReader.IsStartElement("Forecasted"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpForecasted.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                    }

                    decTp.SetData(data, data.SeriesVariables[index], tmpDecSpec, tmpDecComp, tmpForecasted.ToArray());

                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("View"))
                    {
                        tmpString = seriesDataReader.ReadElementContentAsString();
                        if (tmpString == "DECModelSummary") decTp.IsDecModelSummaryVisible = true;
                        else if (tmpString == "DecompositionDataGrid") decTp.IsDecompositionDataGridVisible = true;
                        else if (tmpString == "Trend") decTp.IsTrendVisible = true;
                        else if (tmpString == "Detrend") decTp.IsDetrendVisible = true;
                        else if (tmpString == "Seasonal") decTp.IsSeasonalVisible = true;
                        else if (tmpString == "Deseasonal") decTp.IsDeseasonalVisible = true;
                        //else if (tmpString == "ActualPredictedResidualDataGrid") maTp.IsActualPredictedResidualDataGridVisible = true;
                        else if (tmpString == "ForecastedDataGrid") decTp.IsForecastedDataGridVisible = true;
                        else if (tmpString == "ActualPredictedAndTrendGraph") decTp.IsActualPredictedAndTrendGraphVisible = true;
                        else if (tmpString == "ActualAndForecastedGraph") decTp.IsActualAndForecastedGraphVisible = true;
                        else if (tmpString == "ActualVsPredictedGraph") decTp.IsActualVsPredictedGraphVisible = true;
                        else if (tmpString == "ResidualGraph") decTp.IsResidualGraphVisible = true;
                        else if (tmpString == "ResidualVsActualGraph") decTp.IsResidualVsActualGraphVisible = true;
                        else if (tmpString == "ResidualVsPredictedGraph") decTp.IsResidualVsPredictedGraphVisible = true;
                        else if (tmpString == "DetrendGraph") decTp.IsDetrendGraphVisible = true;
                        else if (tmpString == "DeseasonalGraph") decTp.IsDeseasonalGraphVisible = true;
                    }
                    seriesDataReader.ReadEndElement();

                    decTp.Title = title;
                    decTp.DrawControl();
                    result.Add(decTp);
                    seriesDataReader.ReadEndElement();
                }
                else if (tmpString == "Trend Analysis")
                {
                    TrendAnalysisResultTabPage trendTp = new TrendAnalysisResultTabPage();
                    string title = seriesDataReader.ReadElementContentAsString();
                    tmpString = seriesDataReader.ReadElementContentAsString();
                    int index = VariableFinder.FindVariableIndex(data.SeriesVariables, tmpString);

                    TrendAnalysisForm.TrendSpecification tmpTrendSpec = new TrendAnalysisForm.TrendSpecification();
                    seriesDataReader.ReadStartElement();
                    tmpTrendSpec.includedObservations = seriesDataReader.ReadElementContentAsInt();
                    tmpTrendSpec.r = seriesDataReader.ReadElementContentAsDouble();
                    tmpTrendSpec.rSquare = seriesDataReader.ReadElementContentAsDouble();
                    tmpTrendSpec.rSquareAdjusted = seriesDataReader.ReadElementContentAsDouble();
                    tmpTrendSpec.sse = seriesDataReader.ReadElementContentAsDouble();
                    tmpTrendSpec.mse = seriesDataReader.ReadElementContentAsDouble();
                    tmpTrendSpec.initialModel = seriesDataReader.ReadElementContentAsInt();
                    seriesDataReader.ReadEndElement();

                    List<double> tmpParameters = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpParameters.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();
                    tmpTrendSpec.parameters = tmpParameters.ToArray();

                    List<double> tmpPredicted = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpPredicted.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();

                    List<double> tmpResidual = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpResidual.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();

                    List<double> tmpForecasted = new List<double>();
                    if (seriesDataReader.IsStartElement("Forecasted"))
                    {
                        seriesDataReader.ReadStartElement();
                        while (seriesDataReader.IsStartElement("Value"))
                        {
                            tmpForecasted.Add(seriesDataReader.ReadElementContentAsDouble());
                        }
                        seriesDataReader.ReadEndElement();
                    }

                    trendTp.SetData(data, data.SeriesVariables[index], tmpTrendSpec, tmpPredicted.ToArray(), tmpForecasted.ToArray(), tmpResidual.ToArray());

                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("View"))
                    {
                        tmpString = seriesDataReader.ReadElementContentAsString();
                        if (tmpString == "TrendAnalysisModelSummary") trendTp.IsTrendAnalysisModelSummaryVisible = true;
                        else if (tmpString == "ActualPredictedResidualDataGrid") trendTp.IsActualPredictedResidualDataGridVisible = true;
                        else if (tmpString == "ForecastedDataGrid") trendTp.IsForecastedDataGridVisible = true;
                        else if (tmpString == "ActualAndPredictedGraph") trendTp.IsActualAndPredictedGraphVisible = true;
                        else if (tmpString == "ActualAndForecastedGraph") trendTp.IsActualAndForecastedGraphVisible = true;
                        else if (tmpString == "ActualVsPredictedGraph") trendTp.IsActualVsPredictedGraphVisible = true;
                        else if (tmpString == "ResidualGraph") trendTp.IsResidualGraphVisible = true;
                        else if (tmpString == "ResidualVsActualGraph") trendTp.IsResidualVsActualGraphVisible = true;
                        else if (tmpString == "ResidualVsPredictedGraph") trendTp.IsResidualVsPredictedGraphVisible = true;
                    }
                    seriesDataReader.ReadEndElement();

                    trendTp.Title = title;
                    trendTp.DrawControl();
                    result.Add(trendTp);
                    seriesDataReader.ReadEndElement();
                }
                else if (tmpString == "Correlogram")
                {
                    CorrelogramResult cTp = new CorrelogramResult();
                    string title = seriesDataReader.ReadElementContentAsString();

                    //string lag = seriesDataReader.ReadContentAsString();
                    int lag = seriesDataReader.ReadElementContentAsInt();
                    bool whiteNoise = seriesDataReader.ReadElementContentAsBoolean();

                    //seriesDataReader.ReadStartElement();
                    //string lag = seriesDataReader.ReadElementContentAsString();

                    List<double> tmpData = new List<double>();
                    seriesDataReader.ReadStartElement();
                    while (seriesDataReader.IsStartElement("Value"))
                    {
                        tmpData.Add(seriesDataReader.ReadElementContentAsDouble());
                    }
                    seriesDataReader.ReadEndElement();

                    cTp.SetData(tmpData.ToArray(), lag, whiteNoise);
                    cTp.DisplayResult();
                    cTp.Title = title;
                    result.Add(cTp);
                    seriesDataReader.ReadEndElement();

                }

            }

            seriesDataReader.ReadEndElement();

            return result;
        }