public void SetPreprocessingModel(MultivariatePreprocessingModel val)
		{
			_preprocessingData = val;
		}
        /// <summary>
        /// Exports a table to a PLS2CalibrationSet
        /// </summary>
        /// <param name="table">The table where the calibration model is stored.</param>
        /// <param name="calibrationSet"></param>
        public static void Export(
            DataTable table,
            out PLS1CalibrationModel calibrationSet)
        {
            int numberOfX       = GetNumberOfX(table);
            int numberOfY       = GetNumberOfY(table);
            int numberOfFactors = GetNumberOfFactors(table);

            calibrationSet                 = new PLS1CalibrationModel();
            calibrationSet.NumberOfX       = numberOfX;
            calibrationSet.NumberOfY       = numberOfY;
            calibrationSet.NumberOfFactors = numberOfFactors;
            MultivariatePreprocessingModel preprocessSet = new MultivariatePreprocessingModel();
            MultivariateContentMemento     plsMemo       = table.GetTableProperty("Content") as MultivariateContentMemento;

            if (plsMemo != null)
            {
                preprocessSet.PreprocessOptions = plsMemo.SpectralPreprocessing;
            }
            calibrationSet.SetPreprocessingModel(preprocessSet);

            Altaxo.Collections.AscendingIntegerCollection sel = new Altaxo.Collections.AscendingIntegerCollection();
            Altaxo.Data.DataColumn col;

            col = table[GetXOfX_ColumnName()];
            if (col == null || !(col is INumericColumn))
            {
                NotFound(GetXOfX_ColumnName());
            }
            preprocessSet.XOfX = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector((INumericColumn)col, numberOfX);


            col = table[GetXMean_ColumnName()];
            if (col == null)
            {
                NotFound(GetXMean_ColumnName());
            }
            preprocessSet.XMean = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector(col, numberOfX);

            col = table[GetXScale_ColumnName()];
            if (col == null)
            {
                NotFound(GetXScale_ColumnName());
            }
            preprocessSet.XScale = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector(col, numberOfX);



            sel.Clear();
            col = table[GetYMean_ColumnName()];
            if (col == null)
            {
                NotFound(GetYMean_ColumnName());
            }
            sel.Add(table.DataColumns.GetColumnNumber(col));
            preprocessSet.YMean = DataColumnWrapper.ToROVector(col, numberOfY);

            sel.Clear();
            col = table[GetYScale_ColumnName()];
            if (col == null)
            {
                NotFound(GetYScale_ColumnName());
            }
            sel.Add(table.DataColumns.GetColumnNumber(col));
            preprocessSet.YScale = DataColumnWrapper.ToROVector(col, numberOfY);


            for (int yn = 0; yn < numberOfY; yn++)
            {
                sel.Clear();
                for (int i = 0; i < numberOfFactors; i++)
                {
                    string colname = GetXWeight_ColumnName(yn, i);
                    col = table[colname];
                    if (col == null)
                    {
                        NotFound(colname);
                    }
                    sel.Add(table.DataColumns.GetColumnNumber(col));
                }
                calibrationSet.XWeights[yn] = DataTableWrapper.ToRORowMatrix(table.DataColumns, sel, numberOfX);


                sel.Clear();
                for (int i = 0; i < numberOfFactors; i++)
                {
                    string colname = GetXLoad_ColumnName(yn, i);
                    col = table[colname];
                    if (col == null)
                    {
                        NotFound(colname);
                    }
                    sel.Add(table.DataColumns.GetColumnNumber(col));
                }
                calibrationSet.XLoads[yn] = DataTableWrapper.ToRORowMatrix(table.DataColumns, sel, numberOfX);


                sel.Clear();
                for (int i = 0; i < numberOfFactors; i++)
                {
                    string colname = GetYLoad_ColumnName(yn, i);
                    col = table[colname];
                    if (col == null)
                    {
                        NotFound(colname);
                    }
                    sel.Add(table.DataColumns.GetColumnNumber(col));
                }
                calibrationSet.YLoads[yn] = DataTableWrapper.ToRORowMatrix(table.DataColumns, sel, numberOfY);


                sel.Clear();
                col = table[GetCrossProduct_ColumnName(yn)];
                if (col == null)
                {
                    NotFound(GetCrossProduct_ColumnName());
                }
                sel.Add(table.DataColumns.GetColumnNumber(col));
                calibrationSet.CrossProduct[yn] = DataTableWrapper.ToRORowMatrix(table.DataColumns, sel, numberOfFactors);
            }
        }
		/// <summary>
		/// Exports a table to a PLS2CalibrationSet
		/// </summary>
		/// <param name="table">The table where the calibration model is stored.</param>
		/// <param name="calibrationSet"></param>
		public static void Export(
			DataTable table,
			out PCRCalibrationModel calibrationSet)
		{
			int numberOfX = GetNumberOfX(table);
			int numberOfY = GetNumberOfY(table);
			int numberOfFactors = GetNumberOfFactors(table);
			int numberOfMeasurements = GetNumberOfMeasurements(table);

			calibrationSet = new PCRCalibrationModel();

			calibrationSet.NumberOfX = numberOfX;
			calibrationSet.NumberOfY = numberOfY;
			calibrationSet.NumberOfFactors = numberOfFactors;
			MultivariatePreprocessingModel preprocessSet = new MultivariatePreprocessingModel();
			MultivariateContentMemento plsMemo = table.GetTableProperty("Content") as MultivariateContentMemento;
			if (plsMemo != null)
				preprocessSet.PreprocessOptions = plsMemo.SpectralPreprocessing;
			calibrationSet.SetPreprocessingModel(preprocessSet);

			Altaxo.Collections.AscendingIntegerCollection sel = new Altaxo.Collections.AscendingIntegerCollection();
			Altaxo.Data.DataColumn col;

			col = table.DataColumns.TryGetColumn(GetXOfX_ColumnName());
			if (col == null || !(col is INumericColumn)) NotFound(GetXOfX_ColumnName());
			preprocessSet.XOfX = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector((INumericColumn)col, numberOfX);

			col = table.DataColumns.TryGetColumn(GetXMean_ColumnName());
			if (col == null) NotFound(GetXMean_ColumnName());
			preprocessSet.XMean = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector(col, numberOfX);

			col = table.DataColumns.TryGetColumn(GetXScale_ColumnName());
			if (col == null) NotFound(GetXScale_ColumnName());
			preprocessSet.XScale = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector(col, numberOfX);

			sel.Clear();
			col = table.DataColumns.TryGetColumn(GetYMean_ColumnName());
			if (col == null) NotFound(GetYMean_ColumnName());
			sel.Add(table.DataColumns.GetColumnNumber(col));
			preprocessSet.YMean = DataColumnWrapper.ToROVector(col, numberOfY);

			sel.Clear();
			col = table.DataColumns.TryGetColumn(GetYScale_ColumnName());
			if (col == null) NotFound(GetYScale_ColumnName());
			sel.Add(table.DataColumns.GetColumnNumber(col));
			preprocessSet.YScale = DataColumnWrapper.ToROVector(col, numberOfY);

			sel.Clear();
			for (int i = 0; i < numberOfFactors; i++)
			{
				string colname = GetXScore_ColumnName(i);
				col = table.DataColumns.TryGetColumn(colname);
				if (col == null) NotFound(colname);
				sel.Add(table.DataColumns.GetColumnNumber(col));
			}
			calibrationSet.XScores = DataTableWrapper.ToROColumnMatrix(table.DataColumns, sel, numberOfMeasurements);

			sel.Clear();
			for (int i = 0; i < numberOfFactors; i++)
			{
				string colname = GetXLoad_ColumnName(i);
				col = table.DataColumns.TryGetColumn(colname);
				if (col == null) NotFound(colname);
				sel.Add(table.DataColumns.GetColumnNumber(col));
			}
			calibrationSet.XLoads = DataTableWrapper.ToRORowMatrix(table.DataColumns, sel, numberOfX);

			sel.Clear();
			for (int i = 0; i < numberOfY; i++)
			{
				string colname = GetYLoad_ColumnName(i);
				col = table.DataColumns.TryGetColumn(colname);
				if (col == null) NotFound(colname);
				sel.Add(table.DataColumns.GetColumnNumber(col));
			}
			calibrationSet.YLoads = DataTableWrapper.ToROColumnMatrix(table.DataColumns, sel, numberOfMeasurements);

			sel.Clear();
			col = table.DataColumns.TryGetColumn(GetCrossProduct_ColumnName());
			if (col == null) NotFound(GetCrossProduct_ColumnName());
			calibrationSet.CrossProduct = Altaxo.Calc.LinearAlgebra.DataColumnWrapper.ToROVector(col, numberOfFactors);
		}
    /// <summary>
    /// Preprocesses the x and y matrices before usage in multivariate calibrations.
    /// </summary>
    /// <param name="preprocessOptions">Information how to preprocess the data.</param>
    /// <param name="spectralRegions">Array of ascending indices representing the starting indices of spectral regions.</param>
    /// <param name="matrixX">Matrix of spectra.</param>
    /// <param name="matrixY">Matrix of concentrations.</param>
    /// <returns>The collected data about proprocessing.</returns>
    public static MultivariatePreprocessingModel PreprocessForAnalysis(
      SpectralPreprocessingOptions preprocessOptions,
      int[] spectralRegions,
      IMatrix matrixX, 
      IMatrix matrixY)
    {
      MultivariatePreprocessingModel data = new MultivariatePreprocessingModel();

      data.PreprocessOptions = (SpectralPreprocessingOptions)preprocessOptions.Clone();

      data.SpectralRegions = spectralRegions;

      IVector meanX, scaleX;

      PreprocessSpectraForAnalysis(preprocessOptions,spectralRegions,matrixX,out meanX, out scaleX);

      data.XMean = meanX;
      data.XScale = scaleX;


      IVector meanY, scaleY;

      PreprocessYForAnalysis(matrixY,out meanY, out scaleY);

      data.YMean = meanY;
      data.YScale = scaleY;

      return data;
    
    }
 public void SetPreprocessingModel(MultivariatePreprocessingModel val)
 {
     _preprocessingData = val;
 }