C# DataTable.GetTableProperty方法代码示例

    public  static WorksheetAnalysis GetAnalysis(DataTable table)
    {
      MultivariateContentMemento plsMemo = table.GetTableProperty("Content") as MultivariateContentMemento;

      if(plsMemo==null)
        throw new ArgumentException("Table does not contain a PLSContentMemento");
  
      return plsMemo.Analysis;
    }

		public static MultivariateContentMemento GetContentAsMultivariateContentMemento(DataTable table)
		{
			var result = table.GetTableProperty("Content") as MultivariateContentMemento;
			return result;
		}

		/// <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>
    /// Calculates the leverage of the spectral data.
    /// </summary>
    /// <param name="table">Table where the calibration model is stored.</param>
    /// <param name="numberOfFactors">Number of factors used to calculate leverage.</param>
    public virtual void CalculateXLeverage(
      DataTable table, int numberOfFactors)
    {
      MultivariateContentMemento plsMemo = table.GetTableProperty("Content") as MultivariateContentMemento;

      if(plsMemo==null)
        throw new ArgumentException("Table does not contain a PLSContentMemento");

      IMultivariateCalibrationModel calib = this.GetCalibrationModel(table);
      IMatrix matrixX = GetRawSpectra(plsMemo);

      MultivariateRegression.PreprocessSpectraForPrediction(calib,plsMemo.SpectralPreprocessing,matrixX);

      MultivariateRegression regress = this.CreateNewRegressionObject();
      regress.SetCalibrationModel(calib);

      IROMatrix xLeverage = regress.GetXLeverageFromRaw(matrixX,numberOfFactors);

      for(int i=0;i<xLeverage.Columns;i++)
      {
        Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn();
        MatrixMath.SetColumn(xLeverage,i,DataColumnWrapper.ToVertMatrix(col,xLeverage.Rows),0);
        table.DataColumns.Add(
          col,
          xLeverage.Columns==1 ? GetXLeverage_ColumnName(numberOfFactors) : GetXLeverage_ColumnName(i,numberOfFactors),
          Altaxo.Data.ColumnKind.V,GetXLeverage_ColumnGroup());
      }
    }

    /// <summary>
    /// This predicts the selected columns/rows against a user choosen calibration model.
    /// The orientation of spectra is given by the parameter <c>spectrumIsRow</c>.
    /// </summary>
    /// <param name="srctable">Table holding the specta to predict values for.</param>
    /// <param name="selectedColumns">Columns selected in the source table.</param>
    /// <param name="selectedRows">Rows selected in the source table.</param>
    /// <param name="destTable">The table to store the prediction result.</param>
    /// <param name="modelTable">The table where the calibration model is stored.</param>
    /// <param name="numberOfFactors">Number of factors used to predict the values.</param>
    /// <param name="spectrumIsRow">If true, the spectra is horizontally oriented, else it is vertically oriented.</param>
    public virtual void PredictValues(
      DataTable srctable,
      IAscendingIntegerCollection selectedColumns,
      IAscendingIntegerCollection selectedRows,
      bool spectrumIsRow,
      int numberOfFactors,
      DataTable modelTable,
      DataTable destTable)
    {

      IMultivariateCalibrationModel calibModel = GetCalibrationModel(modelTable);
      //      Export(modelTable, out calibModel);
      MultivariateContentMemento memento = modelTable.GetTableProperty("Content") as MultivariateContentMemento;

      // Fill matrixX with spectra
      Altaxo.Collections.AscendingIntegerCollection spectralIndices;
      Altaxo.Collections.AscendingIntegerCollection measurementIndices;
      
      
      spectralIndices = new Altaxo.Collections.AscendingIntegerCollection(selectedColumns);
      measurementIndices = new Altaxo.Collections.AscendingIntegerCollection(selectedRows);
      RemoveNonNumericCells(srctable,measurementIndices,spectralIndices);

      // exchange selection if spectrum is column
      if(!spectrumIsRow)
      {
        Altaxo.Collections.AscendingIntegerCollection hlp;
        hlp = spectralIndices;
        spectralIndices = measurementIndices;
        measurementIndices = hlp;
      }
      
      // if there are more data than expected, we have to map the spectral indices
      if(spectralIndices.Count>calibModel.NumberOfX)
      {
        double[] xofx = GetXOfSpectra(srctable,spectrumIsRow,spectralIndices,measurementIndices);

        string errormsg;
        AscendingIntegerCollection map = MapSpectralX(calibModel.PreprocessingModel.XOfX,VectorMath.ToROVector(xofx),out errormsg);
        if(map==null)
          throw new ApplicationException("Can not map spectral data: " + errormsg);
        else
        {
          AscendingIntegerCollection newspectralindices = new AscendingIntegerCollection();
          for(int i=0;i<map.Count;i++)
            newspectralindices.Add(spectralIndices[map[i]]);
          spectralIndices = newspectralindices;
        }
      }

      IMatrix matrixX = GetRawSpectra(srctable,spectrumIsRow,spectralIndices,measurementIndices);

      MatrixMath.BEMatrix predictedY = new MatrixMath.BEMatrix(measurementIndices.Count,calibModel.NumberOfY);
      CalculatePredictedY(calibModel,memento.SpectralPreprocessing,matrixX,numberOfFactors, predictedY,null);

      // now save the predicted y in the destination table

      Altaxo.Data.DoubleColumn labelCol = new Altaxo.Data.DoubleColumn();
      for(int i=0;i<measurementIndices.Count;i++)
      {
        labelCol[i] = measurementIndices[i];
      }
      destTable.DataColumns.Add(labelCol,"MeasurementLabel",Altaxo.Data.ColumnKind.Label,0);

      for(int k=0;k<predictedY.Columns;k++)
      {
        Altaxo.Data.DoubleColumn predictedYcol = new Altaxo.Data.DoubleColumn();

        for(int i=0;i<measurementIndices.Count;i++)
        {
          predictedYcol[i] = predictedY[i,k];
        }
        destTable.DataColumns.Add(predictedYcol,"Predicted Y" + k.ToString(), Altaxo.Data.ColumnKind.V,0);
      }

      
    }

    public  virtual void CalculatePredictedAndResidual(
      DataTable table,
      int whichY,
      int numberOfFactors,
      bool saveYPredicted,
      bool saveYResidual,
      bool saveXResidual)
    {
      MultivariateContentMemento plsMemo = table.GetTableProperty("Content") as MultivariateContentMemento;

      if(plsMemo==null)
        throw new ArgumentException("Table does not contain a PLSContentMemento");

      IMultivariateCalibrationModel calib = GetCalibrationModel(table);
      //      Export(table,out calib);


      IMatrix matrixX = GetRawSpectra(plsMemo);

      MatrixMath.BEMatrix predictedY = new MatrixMath.BEMatrix(matrixX.Rows,calib.NumberOfY);
      MatrixMath.BEMatrix spectralResiduals = new MatrixMath.BEMatrix(matrixX.Rows,1);
      CalculatePredictedY(calib,plsMemo.SpectralPreprocessing,matrixX,numberOfFactors,predictedY,spectralResiduals);

      if(saveYPredicted)
      {
        // insert a column with the proper name into the table and fill it
        string ycolname = GetYPredicted_ColumnName(whichY,numberOfFactors);
        Altaxo.Data.DoubleColumn ycolumn = new Altaxo.Data.DoubleColumn();

        for(int i=0;i<predictedY.Rows;i++)
          ycolumn[i] = predictedY[i,whichY];
      
        table.DataColumns.Add(ycolumn,ycolname,Altaxo.Data.ColumnKind.V,GetYPredicted_ColumnGroup());
      }

      // subract the original y data
      IMatrix matrixY = GetOriginalY(plsMemo);
      MatrixMath.SubtractColumn(predictedY,matrixY,whichY,predictedY);

      if(saveYResidual)
      {
        // insert a column with the proper name into the table and fill it
        string ycolname = GetYResidual_ColumnName(whichY,numberOfFactors);
        Altaxo.Data.DoubleColumn ycolumn = new Altaxo.Data.DoubleColumn();

        for(int i=0;i<predictedY.Rows;i++)
          ycolumn[i] = predictedY[i,whichY];
      
        table.DataColumns.Add(ycolumn,ycolname,Altaxo.Data.ColumnKind.V,GetYResidual_ColumnGroup());
      }


      if(saveXResidual)
      {
        // insert a column with the proper name into the table and fill it
        string ycolname = GetXResidual_ColumnName(whichY,numberOfFactors);
        Altaxo.Data.DoubleColumn ycolumn = new Altaxo.Data.DoubleColumn();

        for(int i=0;i<matrixX.Rows;i++)
        {
          ycolumn[i] = spectralResiduals[i,0];
        }
        table.DataColumns.Add(ycolumn,ycolname,Altaxo.Data.ColumnKind.V,GetXResidual_ColumnGroup());
      }
      
    }