public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { MultivariateContentMemento s = null != o ? (MultivariateContentMemento)o : new MultivariateContentMemento(); s.OriginalDataTableName = info.GetString("Name"); s.SpectrumIsRow = info.GetBoolean("SpectrumIsRow"); s.SpectralIndices = (IAscendingIntegerCollection)info.GetValue("SpectralIndices", s); s.ConcentrationIndices = (IAscendingIntegerCollection)info.GetValue("ConcentrationIndices", s); s.MeasurementIndices = (IAscendingIntegerCollection)info.GetValue("MeasurementIndices", s); s._PreferredNumberOfFactors = info.GetInt32("PreferredNumberOfFactors"); // new in version 1 if (info.CurrentElementName == "SpectralPreprocessingRegions") { info.GetArray("SpectralPreprocessingRegions", out int[] regions); s._spectralPreprocessing.Regions = regions; s._spectralPreprocessing.Method = (SpectralPreprocessingMethod)info.GetEnum("SpectralPreprocessingMethod", typeof(SpectralPreprocessingMethod)); s._spectralPreprocessing.DetrendingOrder = info.GetInt32("SpectralPreprocessingDetrending"); s._spectralPreprocessing.EnsembleScale = info.GetBoolean("SpectralPreprocessingEnsembleScale"); } // neccessary since version 2 s.Analysis = new PLS2WorksheetAnalysis(); return(s); }
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { MultivariateContentMemento s = null != o ? (MultivariateContentMemento)o : new MultivariateContentMemento(); s.OriginalDataTableName = info.GetString("Name"); s.SpectrumIsRow = info.GetBoolean("SpectrumIsRow"); s.SpectralIndices = (IAscendingIntegerCollection)info.GetValue("SpectralIndices", s); s.ConcentrationIndices = (IAscendingIntegerCollection)info.GetValue("ConcentrationIndices", s); s.MeasurementIndices = (IAscendingIntegerCollection)info.GetValue("MeasurementIndices", s); s._PreferredNumberOfFactors = info.GetInt32("PreferredNumberOfFactors"); // new in version 1 info.GetArray("SpectralPreprocessingRegions", out int[] regions); s._spectralPreprocessing.Regions = regions; s._spectralPreprocessing.Method = (SpectralPreprocessingMethod)info.GetEnum("SpectralPreprocessingMethod", typeof(SpectralPreprocessingMethod)); s._spectralPreprocessing.DetrendingOrder = info.GetInt32("SpectralPreprocessingDetrending"); s._spectralPreprocessing.EnsembleScale = info.GetBoolean("SpectralPreprocessingEnsembleScale"); // new in version 2 s._ClassNameOfAnalysisClass = info.GetString("ClassNameOfAnalysisClass"); // added fix after version 2 : forgotten to serialize crossPRESSCalculationType if (info.GetNodeName() == "CrossPRESSCalculationType") { s._crossPRESSCalculationType = (CrossPRESSCalculationType)info.GetValue("CrossPRESSCalculationType", s); } else { s._crossPRESSCalculationType = CrossPRESSCalculationType.ExcludeGroupsOfSimilarMeasurements; } return(s); }
public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info) { MultivariateContentMemento s = (MultivariateContentMemento)obj; info.AddValue("TableName", s.TableName); // name of the Table info.AddValue("SpectrumIsRow", s.SpectrumIsRow); info.AddValue("SpectralIndices", s.SpectralIndices); info.AddValue("ConcentrationIndices", s.ConcentrationIndices); info.AddValue("MeasurementIndices", s.MeasurementIndices); info.AddValue("PreferredNumberOfFactors", s._PreferredNumberOfFactors); // the property columns of that table }
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { MultivariateContentMemento s = null != o ? (MultivariateContentMemento)o : new MultivariateContentMemento(); s.OriginalDataTableName = info.GetString("Name"); s.SpectrumIsRow = info.GetBoolean("SpectrumIsRow"); s.SpectralIndices = (IAscendingIntegerCollection)info.GetValue("SpectralIndices", s); s.ConcentrationIndices = (IAscendingIntegerCollection)info.GetValue("ConcentrationIndices", s); s.MeasurementIndices = (IAscendingIntegerCollection)info.GetValue("MeasurementIndices", s); s._PreferredNumberOfFactors = info.GetInt32("PreferredNumberOfFactors"); // neccessary since version 2 s.Analysis = new PLS2WorksheetAnalysis(); return(s); }
public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info) { MultivariateContentMemento s = (MultivariateContentMemento)obj; info.AddValue("TableName", s.TableName); // name of the Table info.AddValue("SpectrumIsRow", s.SpectrumIsRow); info.AddValue("SpectralIndices", s.SpectralIndices); info.AddValue("ConcentrationIndices", s.ConcentrationIndices); info.AddValue("MeasurementIndices", s.MeasurementIndices); info.AddValue("PreferredNumberOfFactors", s._PreferredNumberOfFactors); // the property columns of that table // new in version 1 info.AddArray("SpectralPreprocessingRegions", s._spectralPreprocessing.Regions, s._spectralPreprocessing.Regions.Length); info.AddEnum("SpectralPreprocessingMethod", s._spectralPreprocessing.Method); info.AddValue("SpectralPreprocessingDetrending", s._spectralPreprocessing.DetrendingOrder); info.AddValue("SpectralPreprocessingEnsembleScale", s._spectralPreprocessing.EnsembleScale); }
/// <summary> /// Get the matrix of x and y values (raw data). /// </summary> /// <param name="srctable">The table where the data come from.</param> /// <param name="selectedColumns">The selected columns.</param> /// <param name="selectedRows">The selected rows.</param> /// <param name="selectedPropertyColumns">The selected property column(s).</param> /// <param name="bHorizontalOrientedSpectrum">True if a spectrum is a single row, False if a spectrum is a single column.</param> /// <param name="matrixX">On return, gives the matrix of spectra (each spectra is a row in the matrix).</param> /// <param name="matrixY">On return, gives the matrix of y-values (each measurement is a row in the matrix).</param> /// <param name="plsContent">Holds information about the analysis results.</param> /// <param name="xOfX">On return, this is the vector of values corresponding to each spectral bin, i.e. wavelength values, frequencies etc.</param> /// <returns></returns> public static string GetXYMatrices( Altaxo.Data.DataTable srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows, IAscendingIntegerCollection selectedPropertyColumns, bool bHorizontalOrientedSpectrum, MultivariateContentMemento plsContent, out IMatrix matrixX, out IMatrix matrixY, out IROVector xOfX ) { matrixX = null; matrixY = null; xOfX = null; plsContent.SpectrumIsRow = bHorizontalOrientedSpectrum; Altaxo.Data.DataColumn xColumnOfX = null; Altaxo.Data.DataColumn labelColumnOfX = new Altaxo.Data.DoubleColumn(); Altaxo.Data.DataColumnCollection concentration = bHorizontalOrientedSpectrum ? srctable.DataColumns : srctable.PropertyColumns; // we presume for now that the spectrum is horizontally, // if not we exchange the collections later AscendingIntegerCollection numericDataCols = new AscendingIntegerCollection(); AscendingIntegerCollection numericDataRows = new AscendingIntegerCollection(); AscendingIntegerCollection concentrationIndices = new AscendingIntegerCollection(); AscendingIntegerCollection spectralIndices = bHorizontalOrientedSpectrum ? numericDataCols : numericDataRows; AscendingIntegerCollection measurementIndices = bHorizontalOrientedSpectrum ? numericDataRows : numericDataCols; plsContent.ConcentrationIndices = concentrationIndices; plsContent.MeasurementIndices = measurementIndices; plsContent.SpectralIndices = spectralIndices; plsContent.SpectrumIsRow = bHorizontalOrientedSpectrum; plsContent.OriginalDataTableName = srctable.Name; bool bUseSelectedColumns = (null != selectedColumns && 0 != selectedColumns.Count); // this is the number of columns (for now), but it can be less than this in case // not all columns are numeric int prenumcols = bUseSelectedColumns ? selectedColumns.Count : srctable.DataColumns.ColumnCount; // check for the number of numeric columns int numcols = 0; for (int i = 0; i < prenumcols; i++) { int idx = bUseSelectedColumns ? selectedColumns[i] : i; if (srctable[idx] is Altaxo.Data.INumericColumn) { numericDataCols.Add(idx); numcols++; } } // check the number of rows bool bUseSelectedRows = (null != selectedRows && 0 != selectedRows.Count); int numrows; if (bUseSelectedRows) { numrows = selectedRows.Count; numericDataRows.Add(selectedRows); } else { numrows = 0; for (int i = 0; i < numcols; i++) { int idx = bUseSelectedColumns ? selectedColumns[i] : i; numrows = Math.Max(numrows, srctable[idx].Count); } numericDataRows.Add(ContiguousIntegerRange.FromStartAndCount(0, numrows)); } if (bHorizontalOrientedSpectrum) { if (numcols < 2) return "At least two numeric columns are neccessary to do Partial Least Squares (PLS) analysis!"; // check that the selected columns are in exactly two groups // the group which has more columns is then considered to have // the spectrum, the other group is the y-values int group0 = -1; int group1 = -1; int groupcount0 = 0; int groupcount1 = 0; for (int i = 0; i < numcols; i++) { int grp = srctable.DataColumns.GetColumnGroup(numericDataCols[i]); if (group0 < 0) { group0 = grp; groupcount0 = 1; } else if (group0 == grp) { groupcount0++; } else if (group1 < 0) { group1 = grp; groupcount1 = 1; } else if (group1 == grp) { groupcount1++; } else { return "The columns you selected must be members of two groups (y-values and spectrum), but actually there are more than two groups!"; } } // end for all columns if (groupcount1 <= 0) return "The columns you selected must be members of two groups (y-values and spectrum), but actually only one group was detected!"; if (groupcount1 < groupcount0) { int hlp; hlp = groupcount1; groupcount1 = groupcount0; groupcount0 = hlp; hlp = group1; group1 = group0; group0 = hlp; } // group0 is now the group of y-values (concentrations) // group1 is now the group of x-values (spectra) // we delete group0 from numericDataCols and add it to concentrationIndices for (int i = numcols - 1; i >= 0; i--) { int index = numericDataCols[i]; if (group0 == srctable.DataColumns.GetColumnGroup(index)) { numericDataCols.Remove(index); concentrationIndices.Add(index); } } // fill the corresponding X-Column of the spectra xColumnOfX = Altaxo.Data.DataColumn.CreateColumnOfSelectedRows( srctable.PropertyColumns.FindXColumnOfGroup(group1), spectralIndices); } else // vertically oriented spectrum -> one spectrum is one data column { // we have to exchange measurementIndices and // if PLS on columns, than we should have property columns selected // that designates the y-values // so count all property columns bool bUseSelectedPropCols = (null != selectedPropertyColumns && 0 != selectedPropertyColumns.Count); // this is the number of property columns (for now), but it can be less than this in case // not all columns are numeric int prenumpropcols = bUseSelectedPropCols ? selectedPropertyColumns.Count : srctable.PropCols.ColumnCount; // check for the number of numeric property columns for (int i = 0; i < prenumpropcols; i++) { int idx = bUseSelectedPropCols ? selectedPropertyColumns[i] : i; if (srctable.PropCols[idx] is Altaxo.Data.INumericColumn) { concentrationIndices.Add(idx); } } if (concentrationIndices.Count < 1) return "At least one numeric property column must exist to hold the y-values!"; // fill the corresponding X-Column of the spectra xColumnOfX = Altaxo.Data.DataColumn.CreateColumnOfSelectedRows( srctable.DataColumns.FindXColumnOf(srctable[measurementIndices[0]]), spectralIndices); } // else vertically oriented spectrum IVector xOfXRW = VectorMath.CreateExtensibleVector(xColumnOfX.Count); xOfX = xOfXRW; if (xColumnOfX is INumericColumn) { for (int i = 0; i < xOfX.Length; i++) xOfXRW[i] = ((INumericColumn)xColumnOfX)[i]; } else { for (int i = 0; i < xOfX.Length; i++) xOfXRW[i] = spectralIndices[i]; } // now fill the matrix // fill in the y-values matrixY = new MatrixMath.BEMatrix(measurementIndices.Count, concentrationIndices.Count); for (int i = 0; i < concentrationIndices.Count; i++) { Altaxo.Data.INumericColumn col = concentration[concentrationIndices[i]] as Altaxo.Data.INumericColumn; for (int j = 0; j < measurementIndices.Count; j++) { matrixY[j, i] = col[measurementIndices[j]]; } } // end fill in yvalues matrixX = new MatrixMath.BEMatrix(measurementIndices.Count, spectralIndices.Count); if (bHorizontalOrientedSpectrum) { for (int i = 0; i < spectralIndices.Count; i++) { labelColumnOfX[i] = spectralIndices[i]; Altaxo.Data.INumericColumn col = srctable[spectralIndices[i]] as Altaxo.Data.INumericColumn; for (int j = 0; j < measurementIndices.Count; j++) { matrixX[j, i] = col[measurementIndices[j]]; } } // end fill in x-values } else // vertical oriented spectrum { for (int i = 0; i < spectralIndices.Count; i++) { labelColumnOfX[i] = spectralIndices[i]; } for (int i = 0; i < measurementIndices.Count; i++) { Altaxo.Data.INumericColumn col = srctable[measurementIndices[i]] as Altaxo.Data.INumericColumn; for (int j = 0; j < spectralIndices.Count; j++) { matrixX[i, j] = col[spectralIndices[j]]; } } // end fill in x-values } return null; }
/// <summary> /// Using the information in the plsMemo, gets the matrix of original Y (concentration) data. /// </summary> /// <param name="plsMemo">The PLS mememto containing the information where to find the original data.</param> /// <returns>Matrix of orignal Y (concentration) data.</returns> public static IMatrix GetOriginalY(MultivariateContentMemento plsMemo) { string tablename = plsMemo.OriginalDataTableName; Altaxo.Data.DataTable srctable = Current.Project.DataTableCollection[tablename]; if (srctable == null) throw new ApplicationException(string.Format("Table[{0}] containing original spectral data not found!", tablename)); Altaxo.Data.DataColumnCollection concentration = plsMemo.SpectrumIsRow ? srctable.DataColumns : srctable.PropertyColumns; Altaxo.Collections.IAscendingIntegerCollection concentrationIndices = plsMemo.ConcentrationIndices; Altaxo.Collections.IAscendingIntegerCollection measurementIndices = plsMemo.MeasurementIndices; // fill in the y-values MatrixMath.BEMatrix matrixY = new MatrixMath.BEMatrix(measurementIndices.Count, concentrationIndices.Count); for (int i = 0; i < concentrationIndices.Count; i++) { Altaxo.Data.INumericColumn col = concentration[concentrationIndices[i]] as Altaxo.Data.INumericColumn; for (int j = 0; j < measurementIndices.Count; j++) { matrixY[j, i] = col[measurementIndices[j]]; } } // end fill in yvalues return matrixY; }
/// <summary> /// Using the information in the plsMemo, gets the matrix of original spectra. The spectra are horizontal in the matrix, i.e. each spectra is a matrix row. /// </summary> /// <param name="plsMemo">The PLS memento containing the information about the location of the original data.</param> /// <returns>The matrix of the original spectra.</returns> public static IMatrix GetRawSpectra(MultivariateContentMemento plsMemo) { string tablename = plsMemo.OriginalDataTableName; if (!Current.Project.DataTableCollection.Contains(tablename)) throw new OriginalDataTableNotFoundException(string.Format("The original data table <<{0}>> does not exist, was it renamed?", tablename)); Altaxo.Data.DataTable srctable = Current.Project.DataTableCollection[tablename]; if (srctable == null) throw new ApplicationException(string.Format("Table[{0}] containing original spectral data not found!", tablename)); Altaxo.Collections.IAscendingIntegerCollection spectralIndices = plsMemo.SpectralIndices; Altaxo.Collections.IAscendingIntegerCollection measurementIndices = plsMemo.MeasurementIndices; MatrixMath.BEMatrix matrixX = new MatrixMath.BEMatrix(measurementIndices.Count, spectralIndices.Count); return GetRawSpectra(srctable, plsMemo.SpectrumIsRow, spectralIndices, measurementIndices); }
/// <summary> /// Calculate the cross PRESS values and stores the results in the provided table. /// </summary> /// <param name="xOfX">Vector of spectral wavelengths. Necessary to divide the spectras in different regions.</param> /// <param name="matrixX">Matrix of spectra (horizontal oriented).</param> /// <param name="matrixY">Matrix of concentrations.</param> /// <param name="plsOptions">Analysis options.</param> /// <param name="plsContent">Information about this analysis.</param> /// <param name="table">Table to store the results.</param> public virtual void CalculateCrossPRESS( IROVector xOfX, IMatrix matrixX, IMatrix matrixY, MultivariateAnalysisOptions plsOptions, MultivariateContentMemento plsContent, DataTable table ) { IROVector crossPRESSMatrix; Altaxo.Data.DoubleColumn crosspresscol = new Altaxo.Data.DoubleColumn(); double meanNumberOfExcludedSpectra = 0; if (plsOptions.CrossPRESSCalculation != CrossPRESSCalculationType.None) { // now a cross validation - this can take a long time for bigger matrices MultivariateRegression.GetCrossPRESS( xOfX, matrixX, matrixY, plsOptions.MaxNumberOfFactors, GetGroupingStrategy(plsOptions), plsContent.SpectralPreprocessing, this.CreateNewRegressionObject(), out crossPRESSMatrix); VectorMath.Copy(crossPRESSMatrix, DataColumnWrapper.ToVector(crosspresscol, crossPRESSMatrix.Length)); table.DataColumns.Add(crosspresscol, GetCrossPRESSValue_ColumnName(), Altaxo.Data.ColumnKind.V, 4); plsContent.MeanNumberOfMeasurementsInCrossPRESSCalculation = plsContent.NumberOfMeasurements - meanNumberOfExcludedSpectra; } else { table.DataColumns.Add(crosspresscol, GetCrossPRESSValue_ColumnName(), Altaxo.Data.ColumnKind.V, 4); } }
/// <summary> /// Execute an analysis and stores the result in the provided table. /// </summary> /// <param name="matrixX">The matrix of spectra (horizontal oriented), centered and preprocessed.</param> /// <param name="matrixY">The matrix of concentrations, centered.</param> /// <param name="plsOptions">Information how to perform the analysis.</param> /// <param name="plsContent">A structure to store information about the results of the analysis.</param> /// <param name="table">The table where to store the results to.</param> /// <param name="press">On return, gives a vector holding the PRESS values of the analysis.</param> public virtual void ExecuteAnalysis( IMatrix matrixX, IMatrix matrixY, MultivariateAnalysisOptions plsOptions, MultivariateContentMemento plsContent, DataTable table, out IROVector press ) { int numFactors = Math.Min(matrixX.Columns, plsOptions.MaxNumberOfFactors); MultivariateRegression regress = this.CreateNewRegressionObject(); regress.AnalyzeFromPreprocessed(matrixX, matrixY, numFactors); plsContent.NumberOfFactors = regress.NumberOfFactors; plsContent.CrossValidationType = plsOptions.CrossPRESSCalculation; press = regress.GetPRESSFromPreprocessed(matrixX); Import(regress.CalibrationModel, table); }
/// <summary> /// Makes a PLS (a partial least squares) analysis of the table or the selected columns / rows and stores the results in a newly created table. /// </summary> /// <param name="mainDocument">The main document of the application.</param> /// <param name="srctable">The table where the data come from.</param> /// <param name="selectedColumns">The selected columns.</param> /// <param name="selectedRows">The selected rows.</param> /// <param name="selectedPropertyColumns">The selected property column(s).</param> /// <param name="bHorizontalOrientedSpectrum">True if a spectrum is a single row, False if a spectrum is a single column.</param> /// <param name="plsOptions">Provides information about the max number of factors and the calculation of cross PRESS value.</param> /// <param name="preprocessOptions">Provides information about how to preprocess the spectra.</param> /// <returns></returns> public virtual string ExecuteAnalysis( Altaxo.AltaxoDocument mainDocument, Altaxo.Data.DataTable srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows, IAscendingIntegerCollection selectedPropertyColumns, bool bHorizontalOrientedSpectrum, MultivariateAnalysisOptions plsOptions, SpectralPreprocessingOptions preprocessOptions ) { IMatrix matrixX, matrixY; IROVector xOfX; var plsContent = new MultivariateContentMemento(); plsContent.Analysis = this; // now we have to create a new table where to place the calculated factors and loads // we will do that in a vertical oriented manner, i.e. even if the loads are // here in horizontal vectors: in our table they are stored in (vertical) columns string newName = this.AnalysisName + " of " + Main.ProjectFolder.GetNamePart(srctable.Name); newName = Main.ProjectFolder.CreateFullName(srctable.Name, newName); Altaxo.Data.DataTable table = new Altaxo.Data.DataTable(newName); // Fill the Table using (var suspendToken = table.SuspendGetToken()) { table.SetTableProperty("Content", plsContent); plsContent.OriginalDataTableName = srctable.Name; // Get matrices GetXYMatrices( srctable, selectedColumns, selectedRows, selectedPropertyColumns, bHorizontalOrientedSpectrum, plsContent, out matrixX, out matrixY, out xOfX); StoreXOfX(xOfX, table); // Preprocess plsContent.SpectralPreprocessing = preprocessOptions; IVector meanX, scaleX, meanY, scaleY; MultivariateRegression.PreprocessForAnalysis(preprocessOptions, xOfX, matrixX, matrixY, out meanX, out scaleX, out meanY, out scaleY); StorePreprocessedData(meanX, scaleX, meanY, scaleY, table); // Analyze and Store IROVector press; ExecuteAnalysis( matrixX, matrixY, plsOptions, plsContent, table, out press); this.StorePRESSData(press, table); if (plsOptions.CrossPRESSCalculation != CrossPRESSCalculationType.None) CalculateCrossPRESS(xOfX, matrixX, matrixY, plsOptions, plsContent, table); StoreFRatioData(table, plsContent); StoreOriginalY(table, plsContent); suspendToken.Dispose(); } Current.Project.DataTableCollection.Add(table); // create a new worksheet without any columns Current.ProjectService.CreateNewWorksheet(table); return null; }
public virtual void StoreFRatioData( DataTable table, MultivariateContentMemento plsContent) { DoubleColumn pressColumn = null; DoubleColumn crossPRESSColumn = null; if (table.DataColumns.Contains(GetPRESSValue_ColumnName())) pressColumn = table[GetPRESSValue_ColumnName()] as DoubleColumn; if (table.DataColumns.Contains(GetCrossPRESSValue_ColumnName())) crossPRESSColumn = table[GetCrossPRESSValue_ColumnName()] as DoubleColumn; IROVector press; double meanNumberOfIncludedSpectra = plsContent.NumberOfMeasurements; if (crossPRESSColumn != null && crossPRESSColumn.Count > 0) { press = DataColumnWrapper.ToROVector(crossPRESSColumn); meanNumberOfIncludedSpectra = plsContent.MeanNumberOfMeasurementsInCrossPRESSCalculation; } else if (pressColumn != null && pressColumn.Count > 0) { press = DataColumnWrapper.ToROVector(pressColumn); meanNumberOfIncludedSpectra = plsContent.NumberOfMeasurements; } else return; // calculate the F-ratio and the F-Probability int numberOfSignificantFactors = press.Length; double pressMin = double.MaxValue; for (int i = 0; i < press.Length; i++) pressMin = Math.Min(pressMin, press[i]); DoubleColumn fratiocol = new DoubleColumn(); DoubleColumn fprobcol = new DoubleColumn(); for (int i = 0; i < press.Length; i++) { double fratio = press[i] / pressMin; double fprob = Calc.Probability.FDistribution.CDF(fratio, meanNumberOfIncludedSpectra, meanNumberOfIncludedSpectra); fratiocol[i] = fratio; fprobcol[i] = fprob; if (fprob < 0.75 && numberOfSignificantFactors > i) numberOfSignificantFactors = i; } plsContent.PreferredNumberOfFactors = numberOfSignificantFactors; table.DataColumns.Add(fratiocol, _FRatio_ColumnName, Altaxo.Data.ColumnKind.V, _FRatio_ColumnGroup); table.DataColumns.Add(fprobcol, _FProbability_ColumnName, Altaxo.Data.ColumnKind.V, _FProbability_ColumnGroup); }
public PredictionModelExporter(Altaxo.Data.DataTable table, int numberOfFactors) { _table = table; _memento = table.GetTableProperty("Content") as MultivariateContentMemento; _numberOfFactors = numberOfFactors; }
public static void QuestPreferredNumberOfFactors(MultivariateContentMemento plsMemo) { // quest the number of factors to export IntegerValueInputController ivictrl = new IntegerValueInputController(1,"Please choose preferred number of factors(>0):"); ivictrl.Validator = new IntegerValueInputController.ZeroOrPositiveIntegerValidator(); if(!Current.Gui.ShowDialog(ivictrl,"Number of factors",false)) return; plsMemo.PreferredNumberOfFactors = ivictrl.EnteredContents; }
public void StoreOriginalY( DataTable table, MultivariateContentMemento plsContent ) { IMatrix matrixY = GetOriginalY(plsContent); IMultivariateCalibrationModel calib = GetCalibrationModel(table); // add a label column for the measurement number Altaxo.Data.DoubleColumn measurementLabel = new Altaxo.Data.DoubleColumn(); for (int i = 0; i < plsContent.MeasurementIndices.Count; i++) measurementLabel[i] = plsContent.MeasurementIndices[i]; table.DataColumns.Add(measurementLabel, _MeasurementLabel_ColumnName, Altaxo.Data.ColumnKind.Label, _MeasurementLabel_ColumnGroup); // now add the original Y-Columns for (int i = 0; i < matrixY.Columns; i++) { Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for (int j = 0; j < matrixY.Rows; j++) col[j] = matrixY[j, i]; table.DataColumns.Add(col, _YOriginal_ColumnName + i.ToString(), Altaxo.Data.ColumnKind.X, 5 + i); } }
/// <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); } }