/// <summary> /// Creates the collection copied from another <see cref="IAscendingIntegerCollection" />. /// </summary> /// <param name="from"></param> public AscendingIntegerCollection(IAscendingIntegerCollection from) { for (int i = 0; i < from.Count; i++) { this.Add(from[i]); } }
/// <summary> /// Sets the group number of the currently selected columns to <code>nGroup</code>. /// </summary> /// <param name="datacoll">The data column collection to which to apply this procedure.</param> /// <param name="selected">Collection of column indices for which to set the group number.</param> /// <param name="nGroup">The group number to set for the selected columns.</param> public static void SetColumnGroupNumber(this DataColumnCollection datacoll, IAscendingIntegerCollection selected, int nGroup) { for (int i = 0; i < selected.Count; i++) { datacoll.SetColumnGroup(selected[i], nGroup); } }
/// <summary> /// Sets the group number of the selected column /// </summary> /// <param name="dataTable">The data table</param> /// <param name="selectedDataColumns">Indices of the currently selected data column of the table</param> /// <param name="selectedPropColumns">Indices of the currently selected property columns of the table.</param> public static bool ShowSetColumnGroupNumberDialog(this DataTable dataTable, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedPropColumns) { if (selectedDataColumns.Count > 0 || selectedPropColumns.Count > 0) { int grpNumber = 0; if (selectedDataColumns.Count > 0) { grpNumber = dataTable.DataColumns.GetColumnGroup(selectedDataColumns[0]); } else if (selectedPropColumns.Count > 0) { grpNumber = dataTable.PropertyColumns.GetColumnGroup(selectedPropColumns[0]); } var ivictrl = new IntegerValueInputController(grpNumber, "Please enter a group number (>=0):") { Validator = new IntegerValueInputController.ZeroOrPositiveIntegerValidator() }; if (Current.Gui.ShowDialog(ivictrl, "Set group number", false)) { SetColumnGroupNumber(dataTable, selectedDataColumns, selectedPropColumns, ivictrl.EnteredContents); return(true); } } return(false); }
public void Dispose() { _col = null; _srctable = null; _selectedColumns = null; _selectedRows = null; }
public XYZMeshedColumnPlotData(Altaxo.Data.DataColumnCollection coll, IAscendingIntegerCollection selected) { m_XColumn = new Altaxo.Data.IndexerColumn(); m_YColumn = new Altaxo.Data.IndexerColumn(); int len = selected == null ? coll.ColumnCount : selected.Count; m_DataColumns = new Altaxo.Data.IReadableColumn[len]; for (int i = 0; i < len; i++) { int idx = null == selected ? i : selected[i]; m_DataColumns[i] = coll[idx]; // set the event chain if (m_DataColumns[i] is Altaxo.Data.DataColumn) { ((Altaxo.Data.DataColumn)m_DataColumns[i]).Changed += new EventHandler(EhColumnDataChangedEventHandler); } } this.SetXBoundsFromTemplate(new FiniteNumericalBoundaries()); this.SetYBoundsFromTemplate(new FiniteNumericalBoundaries()); this.SetVBoundsFromTemplate(new FiniteNumericalBoundaries()); }
/// <summary> /// Determines which of the rows of a set of columns is truly numeric, i.e. all columns in this row contains a value, which is not double.NaN. /// </summary> /// <param name="table">Array of numeric columns.</param> /// <param name="selectedCols">The indizes of the columns in question into the collection.</param> /// <param name="selectedRowIndices">The selected data row indices.</param> /// <param name="rowCount">The minimum row count of all the selected columns.</param> /// <returns>A boolean array. If an element of the array is true at a given index, that row contains valid numeric values in all columns.</returns> public static bool[] GetValidNumericRows(IReadableColumn[] table, IAscendingIntegerCollection selectedCols, IEnumerable <int> selectedRowIndices, int rowCount) { // determine the number of valid rows bool[] rowValid = new bool[rowCount]; foreach (int i in selectedRowIndices) { rowValid[i] = true; } for (int i = 0; i < selectedCols.Count; i++) { var col = table[selectedCols[i]]; if (col is null) { for (int j = 0; j < rowCount; j++) { rowValid[j] = false; } } else { for (int j = 0; j < rowCount; j++) { if (double.IsNaN(col[j])) { rowValid[j] = false; } } } } return(rowValid); }
public static List<IGPlotItem> CreatePlotItems(DataTable table, IAscendingIntegerCollection selectedColumns, G3DPlotStyleCollection templatePlotStyle) { var selColumns = new List<DataColumn>(selectedColumns.Count); foreach (int i in selectedColumns) selColumns.Add(table[i]); return CreatePlotItems(selColumns, templatePlotStyle, table.GetPropertyContext()); }
public static LinearFitBySvd Regress(MultivariateLinearFitParameters parameters, out string[] paramNames) { DataColumnCollection table = parameters.Table; IAscendingIntegerCollection selectedCols = parameters.SelectedDataColumns; var selectedColsWODependent = new AscendingIntegerCollection(selectedCols); selectedColsWODependent.RemoveAt(parameters.DependentColumnIndexIntoSelection); IAscendingIntegerCollection validRows = DataTableWrapper.GetCollectionOfValidNumericRows(parameters.Table, selectedCols); parameters.SelectedDataRows = validRows; IROMatrix <double> xbase; if (parameters.IncludeIntercept) { xbase = DataTableWrapper.ToROColumnMatrixWithIntercept(parameters.Table, selectedColsWODependent, validRows); } else { xbase = DataTableWrapper.ToROColumnMatrix(parameters.Table, selectedColsWODependent, validRows); } paramNames = new string[xbase.ColumnCount]; if (parameters.IncludeIntercept) { paramNames[0] = "Intercept"; for (int i = 0; i < selectedColsWODependent.Count; i++) { paramNames[i + 1] = table[selectedColsWODependent[i]].Name; } } else { for (int i = 0; i < selectedColsWODependent.Count; i++) { paramNames[i] = table[selectedColsWODependent[i]].Name; } } // Fill the y and the error array double[] yarr = new double[validRows.Count]; double[] earr = new double[validRows.Count]; var ycol = (Altaxo.Data.INumericColumn)table[selectedCols[parameters.DependentColumnIndexIntoSelection]]; for (int i = 0; i < validRows.Count; i++) { yarr[i] = ycol[validRows[i]]; earr[i] = 1; } var fit = new LinearFitBySvd( xbase, yarr, earr, xbase.RowCount, xbase.ColumnCount, 1E-5); return(fit); }
/// <summary> /// Remove the selected data columns <b>and the corresponding property rows</b>. /// </summary> /// <param name="selectedColumns">A collection of the indizes to the columns that have to be removed.</param> public virtual void RemoveColumns(IAscendingIntegerCollection selectedColumns) { Suspend(); _dataColumns.RemoveColumns(selectedColumns); // remove the columns from the collection _propertyColumns.RemoveRows(selectedColumns); // remove also the corresponding rows from the Properties Resume(); }
/// <summary> /// Adds all values from another <see cref="IAscendingIntegerCollection" />. /// </summary> /// <param name="from">The source collection.</param> public void Add(IAscendingIntegerCollection from) { int end = from.Count; for (int i = 0; i < end; i++) { Add(from[i]); } }
public static void SetColumnGroupNumber( this DataTable dataTable, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedPropColumns, int nGroup) { SetColumnGroupNumber(dataTable.DataColumns, selectedDataColumns, nGroup); SetColumnGroupNumber(dataTable.PropCols, selectedPropColumns, nGroup); }
/// <summary> /// Calculates statistics of selected columns. Returns a new table where the statistical data will be written to. /// </summary> /// <param name="srctable">Source table.</param> /// <param name="selectedColumns">Selected data columns in the source table.</param> /// <param name="selectedRows">Selected rows in the source table.</param> public static DataTable DoStatisticsOnColumns( this DataColumnCollection srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows ) { var table = CreateStatisticalTable(srctable, selectedColumns); DoStatisticsOnColumns(srctable, selectedColumns, selectedRows, table.DataColumns); return table; }
public XYZMeshedColumnPlotData(DataTable table, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedPropertyColumns) { _matrixProxy = new DataTableMatrixProxy(table, selectedDataRows, selectedDataColumns, selectedPropertyColumns) { ParentObject = this }; SetXBoundsFromTemplate(new FiniteNumericalBoundaries()); SetYBoundsFromTemplate(new FiniteNumericalBoundaries()); SetVBoundsFromTemplate(new FiniteNumericalBoundaries()); }
/// <summary> /// Calculates the jacobian values, i.e. the derivatives of the fitting values with respect to the parameters. /// </summary> /// <param name="parameter">The parameter used to calculate the values.</param> /// <param name="outputValues">You must provide an array to hold the calculated values. Size of the array must be /// at least <see cref="NumberOfData" />*<see cref="FitElement.NumberOfParameters" />.</param> /// <param name="adata">Currently ignored.</param> /// <remarks>The values of the fit elements are stored in the order from element_0 to element_n*m. If there is more /// than one used dependent variable per fit element, the output values are stored in interleaved order. The derivatives /// on one fitting value are stored in successive order. /// </remarks> public void EvaluateFitJacobian(double[] parameter, double[] outputValues, object adata) { outputValues.Initialize(); // make sure every element contains zero int outputValuesPointer = 0; for (int ele = 0; ele < _cachedFitElementInfo.Length; ele++) { CachedFitElementInfo info = _cachedFitElementInfo[ele]; FitElement fitEle = _fitEnsemble[ele]; // make sure, that the dimension of the DYs is ok if (info.DYs == null || info.DYs.Length != fitEle.NumberOfDependentVariables || info.DYs[0].Length != fitEle.NumberOfParameters) { info.DYs = LinearAlgebra.JaggedArrayMath.GetMatrixArray(fitEle.NumberOfDependentVariables, fitEle.NumberOfParameters); } // copy of the parameter to the temporary array for (int i = 0; i < info.Parameters.Length; i++) { int idx = info.ParameterMapping[i]; info.Parameters[i] = idx >= 0 ? parameter[idx] : _constantParameters[-1 - idx]; } IAscendingIntegerCollection validRows = info.ValidRows; int numValidRows = validRows.Count; // Evaluate the function for all points for (int i = 0; i < numValidRows; ++i) { for (int k = info.Xs.Length - 1; k >= 0; k--) { info.Xs[k] = fitEle.IndependentVariables(k)[validRows[i]]; } ((IFitFunctionWithGradient)fitEle.FitFunction).EvaluateGradient(info.Xs, info.Parameters, info.DYs); // copy the evaluation result to the output array (interleaved) for (int k = 0; k < info.DependentVariablesInUse.Length; ++k) { for (int l = 0; l < info.Parameters.Length; ++l) { int idx = info.ParameterMapping[l]; if (idx >= 0) { outputValues[outputValuesPointer + idx] += info.DYs[info.DependentVariablesInUse[k]][l]; } } outputValuesPointer += parameter.Length; // increase output pointer only by the varying (!) number of parameters } } } }
/// <summary> /// Creates the controller for the Galactic SPC file export dialog. /// </summary> /// <param name="table">The data table which is about to be exported.</param> /// <param name="selectedRows">The selected rows of the data table.</param> /// <param name="selectedColumns">The selected columns of the data table.</param> public ExportGalacticSpcFileDialogController( Altaxo.Data.DataTable table, IAscendingIntegerCollection selectedRows, IAscendingIntegerCollection selectedColumns) { m_Table = table; m_SelectedRows = selectedRows; m_SelectedColumns = selectedColumns; InitializeElements(); }
/// <summary> /// Calculates statistics of selected columns. Returns a new table where the statistical data will be written to. /// </summary> /// <param name="srctable">Source table.</param> /// <param name="selectedColumns">Selected data columns in the source table.</param> /// <param name="selectedRows">Selected rows in the source table.</param> public static DataTable DoStatisticsOnColumns( this DataColumnCollection srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows ) { var table = CreateStatisticalTable(srctable, selectedColumns); DoStatisticsOnColumns(srctable, selectedColumns, selectedRows, table.DataColumns); return(table); }
/// <summary> /// Plots selected data columns of a table. /// </summary> /// <param name="table">The source table.</param> /// <param name="selectedColumns">The data columns of the table that should be plotted.</param> /// <param name="graph">The graph document to plot into.</param> /// <param name="templatePlotStyle">The plot style which is the template for all plot items.</param> /// <param name="groupStyles">The group styles for the newly built plot item collection.</param> public static Altaxo.Gui.Graph.Gdi.Viewing.IGraphController Plot( DataTable table, IAscendingIntegerCollection selectedColumns, Graph.Gdi.GraphDocument graph, G2DPlotStyleCollection templatePlotStyle, PlotGroupStyleCollection groupStyles) { List <IGPlotItem> pilist = CreatePlotItems(table, selectedColumns, templatePlotStyle); // now create a new Graph with this plot associations var gc = Current.ProjectService.CreateNewGraph(graph); var xylayer = gc.Doc.RootLayer.Layers.OfType <Altaxo.Graph.Gdi.XYPlotLayer>().First(); // Set x and y axes according to the first plot item in the list if (pilist.Count > 0 && (pilist[0] is XYColumnPlotItem)) { var firstitem = (XYColumnPlotItem)pilist[0]; if (firstitem.Data.XColumn is TextColumn) { xylayer.Scales[0] = new TextScale(); } else if (firstitem.Data.XColumn is DateTimeColumn) { xylayer.Scales[0] = new DateTimeScale(); } if (firstitem.Data.YColumn is TextColumn) { xylayer.Scales[1] = new TextScale(); } else if (firstitem.Data.YColumn is DateTimeColumn) { xylayer.Scales[1] = new DateTimeScale(); } } var newPlotGroup = new PlotItemCollection(xylayer.PlotItems); foreach (IGPlotItem pi in pilist) { newPlotGroup.Add(pi); } if (groupStyles != null) { newPlotGroup.GroupStyles = groupStyles; } else { newPlotGroup.CollectStyles(newPlotGroup.GroupStyles); } xylayer.PlotItems.Add(newPlotGroup); return(gc); }
/// <summary> /// Sets the data columns from an enumeration of data column proxies. /// </summary> /// <param name="dataRows">The enumeration of data rows.</param> public void SetDataRows(IAscendingIntegerCollection dataRows) { _participatingDataRows.Clear(); foreach (var range in dataRows.RangesAscending) { _participatingDataRows.AddRange(range.Start, range.Count); } _isDirty = true; }
public static List <IGPlotItem> CreatePlotItems(DataTable table, IAscendingIntegerCollection selectedColumns, G3DPlotStyleCollection templatePlotStyle) { var selColumns = new List <DataColumn>(selectedColumns.Count); foreach (int i in selectedColumns) { selColumns.Add(table[i]); } return(CreatePlotItems(selColumns, templatePlotStyle, table.GetPropertyContext())); }
/// <summary> /// Constructor. Besides the table, the current selections must be provided. Only the areas that corresponds to the selections are /// serialized. The serialization process has to occur immediately after this constructor, because only a reference /// to the table is hold by this object. /// </summary> /// <param name="table">The table to serialize.</param> /// <param name="selectedDataColumns">The selected data columns.</param> /// <param name="selectedDataRows">The selected data rows.</param> /// <param name="selectedPropertyColumns">The selected property columns.</param> /// <param name="selectedPropertyRows">The selected property rows.</param> public ClipboardMemento(DataTable table, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedPropertyColumns, IAscendingIntegerCollection selectedPropertyRows ) { this._table = table; this._selectedDataColumns = selectedDataColumns; this._selectedDataRows = selectedDataRows; this._selectedPropertyColumns = selectedPropertyColumns; this._selectedPropertyRows = selectedPropertyRows; }
/// <summary> /// Gets the indices of the data rows of the table that contribute to the matrix. /// </summary> /// <returns></returns> public IAscendingIntegerCollection GetParticipatingDataRows() { if (null == _participatingDataColumns) { GetParticipatingDataColumns(); } if (null == _participatingDataRows) { _participatingDataRows = GetParticipatingDataRows(_sourceTable, _selectedRows, _participatingDataColumns); } return(_participatingDataRows); }
/// <summary> /// Shows the dialog in which the user can select options for the 2D Fourier transformation, and then executes the Fourier transformation /// The result is stored in a newly created data table in the same folder as the source data table. /// </summary> /// <param name="table">The table containing the data to transform.</param> /// <param name="selectedDataRows">The selected data rows of the table. (A value of <c>null</c> can be provided here).</param> /// <param name="selectedDataColumns">The selected data columns of the table. (A value of <c>null</c> can be provided here).</param> /// <param name="selectedPropertyColumns">The selected property columns of the table. (A value of <c>null</c> can be provided here).</param> public static void ShowRealFourierTransformation2DDialog(DataTable table, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedPropertyColumns) { DataTableMatrixProxy proxy = null; RealFourierTransformation2DOptions options = null; try { proxy = new DataTableMatrixProxy(table, selectedDataRows, selectedDataColumns, selectedPropertyColumns); options = null != _lastUsedOptions ? (RealFourierTransformation2DOptions)_lastUsedOptions.Clone() : new RealFourierTransformation2DOptions(); proxy.TryGetRowHeaderIncrement(out var rowIncrementValue, out var rowIncrementMessage); proxy.TryGetColumnHeaderIncrement(out var columnIncrementValue, out var columnIncrementMessage); options.IsUserDefinedRowIncrementValue = false; options.RowIncrementValue = rowIncrementValue; options.RowIncrementMessage = rowIncrementMessage; options.IsUserDefinedColumnIncrementValue = false; options.ColumnIncrementValue = columnIncrementValue; options.ColumnIncrementMessage = columnIncrementMessage; } catch (Exception ex) { Current.Gui.ErrorMessageBox(string.Format("{0}\r\nDetails:\r\n{1}", ex.Message, ex.ToString()), "Error in preparation of Fourier transformation"); return; } if (!Current.Gui.ShowDialog(ref options, "Choose fourier transform options", false)) { return; } _lastUsedOptions = options; try { var resultTable = new DataTable { Name = string.Format("{0}Fourier{1} of {2}", table.Folder, options.OutputKind, table.ShortName) }; ExecuteFouriertransformation2D(proxy, options, resultTable); // Create a DataSource var dataSource = new FourierTransformation2DDataSource(proxy, options, new Altaxo.Data.DataSourceImportOptions()); resultTable.DataSource = dataSource; Current.ProjectService.OpenOrCreateWorksheetForTable(resultTable); } catch (Exception ex) { Current.Gui.ErrorMessageBox(string.Format("{0}\r\nDetails:\r\n{1}", ex.Message, ex.ToString()), "Error in execution of Fourier transformation"); return; } }
/// <summary> /// Creates a table for statistics on columns. Property columns are included in the statistical table. /// </summary> /// <param name="srcTable"></param> /// <param name="selectedColumns"></param> /// <returns></returns> private static DataTable CreateStatisticalTable(DataTable srcTable, IAscendingIntegerCollection selectedColumns) { var result = new DataTable { Name = Altaxo.Main.ProjectFolder.PrependToName(srcTable.Name, "Statistics of ") }; result.DataColumns.Add(new TextColumn(), DefaultColumnNameColumnName, ColumnKind.X, 0); AddSourcePropertyColumns(srcTable, selectedColumns, result); AddStatisticColumns(result); return(result); }
/// <summary> /// Plots selected data columns of a table. /// </summary> /// <param name="table">The source table.</param> /// <param name="selectedColumns">The data columns of the table that should be plotted.</param> /// <param name="graph">The graph document to plot into.</param> /// <param name="templatePlotStyle">The plot style which is the template for all plot items.</param> /// <param name="groupStyles">The group styles for the newly built plot item collection.</param> public static IGraphController Plot(DataTable table, IAscendingIntegerCollection selectedColumns, Graph.Gdi.GraphDocument graph, G2DPlotStyleCollection templatePlotStyle, PlotGroupStyleCollection groupStyles) { List <IGPlotItem> pilist = CreatePlotItems(table, selectedColumns, templatePlotStyle); // now create a new Graph with this plot associations Altaxo.Graph.GUI.IGraphController gc = Current.ProjectService.CreateNewGraph(graph); // Set x and y axes according to the first plot item in the list if (pilist.Count > 0 && (pilist[0] is XYColumnPlotItem)) { XYColumnPlotItem firstitem = (XYColumnPlotItem)pilist[0]; if (firstitem.Data.XColumn is TextColumn) { gc.Doc.Layers[0].LinkedScales.SetScale(0, new Graph.Scales.TextScale()); } else if (firstitem.Data.XColumn is DateTimeColumn) { gc.Doc.Layers[0].LinkedScales.SetScale(0, new Graph.Scales.DateTimeScale()); } if (firstitem.Data.YColumn is TextColumn) { gc.Doc.Layers[0].LinkedScales.SetScale(1, new Graph.Scales.TextScale()); } else if (firstitem.Data.YColumn is DateTimeColumn) { gc.Doc.Layers[0].LinkedScales.SetScale(1, new Graph.Scales.DateTimeScale()); } } PlotItemCollection newPlotGroup = new PlotItemCollection(gc.Doc.Layers[0].PlotItems); foreach (IGPlotItem pi in pilist) { newPlotGroup.Add(pi); } if (groupStyles != null) { newPlotGroup.GroupStyles = groupStyles; } else { newPlotGroup.CollectStyles(newPlotGroup.GroupStyles); } gc.Doc.Layers[0].PlotItems.Add(newPlotGroup); return(gc); }
public static void ShowActionDialog(this DataTable srcTable, IAscendingIntegerCollection selectedDataColumns) { DataTableMultipleColumnProxy proxy = null; ConvertXYVToMatrixOptions options = null; try { proxy = new DataTableMultipleColumnProxy(ConvertXYVToMatrixDataAndOptions.ColumnV, srcTable, null, selectedDataColumns); proxy.EnsureExistenceOfIdentifier(ConvertXYVToMatrixDataAndOptions.ColumnX, 1); proxy.EnsureExistenceOfIdentifier(ConvertXYVToMatrixDataAndOptions.ColumnY, 1); options = new ConvertXYVToMatrixOptions(); } catch (Exception ex) { Current.Gui.ErrorMessageBox(string.Format("{0}\r\nDetails:\r\n{1}", ex.Message, ex.ToString()), "Error in preparation of 'Convert X-Y-V values to matrix'"); return; } var dataAndOptions = new ConvertXYVToMatrixDataAndOptions(proxy, options); // in order to show the column names etc in the dialog, it is neccessary to set the source if (true == Current.Gui.ShowDialog(ref dataAndOptions, "Choose options", false)) { var destTable = new DataTable(); proxy = dataAndOptions.Data; options = dataAndOptions.Options; string error = null; try { error = ConvertXYVToMatrix(dataAndOptions.Data, dataAndOptions.Options, destTable); } catch (Exception ex) { error = ex.ToString(); } if (null != error) { Current.Gui.ErrorMessageBox(error); } destTable.Name = srcTable.Name + "_Decomposed"; // Create a DataSource var dataSource = new ConvertXYVToMatrixDataSource(proxy, options, new Altaxo.Data.DataSourceImportOptions()); destTable.DataSource = dataSource; Current.Project.DataTableCollection.Add(destTable); Current.IProjectService.ShowDocumentView(destTable); } }
/// <summary> /// Shows the dialog in which the user can select options for the 2D Fourier transformation, and then executes the Fourier transformation /// The result is stored in a newly created data table in the same folder as the source data table. /// </summary> /// <param name="table">The table containing the data to transform.</param> /// <param name="selectedDataRows">The selected data rows of the table. (A value of <c>null</c> can be provided here).</param> /// <param name="selectedDataColumns">The selected data columns of the table. (A value of <c>null</c> can be provided here).</param> /// <param name="selectedPropertyColumns">The selected property columns of the table. (A value of <c>null</c> can be provided here).</param> public static void ShowRealFourierTransformation2DDialog(DataTable table, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedPropertyColumns) { DataTableMatrixProxy proxy = null; RealFourierTransformation2DOptions options = null; try { proxy = new DataTableMatrixProxy(table, selectedDataRows, selectedDataColumns, selectedPropertyColumns); options = null != _lastUsedOptions ? (RealFourierTransformation2DOptions)_lastUsedOptions.Clone() : new RealFourierTransformation2DOptions(); double rowIncrementValue; string rowIncrementMessage; proxy.TryGetRowHeaderIncrement(out rowIncrementValue, out rowIncrementMessage); double columnIncrementValue; string columnIncrementMessage; proxy.TryGetColumnHeaderIncrement(out columnIncrementValue, out columnIncrementMessage); options.IsUserDefinedRowIncrementValue = false; options.RowIncrementValue = rowIncrementValue; options.RowIncrementMessage = rowIncrementMessage; options.IsUserDefinedColumnIncrementValue = false; options.ColumnIncrementValue = columnIncrementValue; options.ColumnIncrementMessage = columnIncrementMessage; } catch (Exception ex) { Current.Gui.ErrorMessageBox(string.Format("{0}\r\nDetails:\r\n{1}", ex.Message, ex.ToString()), "Error in preparation of Fourier transformation"); return; } if (!Current.Gui.ShowDialog(ref options, "Choose fourier transform options", false)) return; _lastUsedOptions = options; try { var resultTable = new DataTable { Name = string.Format("{0}Fourier{1} of {2}", table.Folder, options.OutputKind, table.ShortName) }; ExecuteFouriertransformation2D(proxy, options, resultTable); // Create a DataSource Altaxo.Worksheet.Commands.Analysis.FourierTransformation2DDataSource dataSource = new FourierTransformation2DDataSource(proxy, options, new Altaxo.Data.DataSourceImportOptions()); resultTable.DataSource = dataSource; Current.ProjectService.OpenOrCreateWorksheetForTable(resultTable); } catch (Exception ex) { Current.Gui.ErrorMessageBox(string.Format("{0}\r\nDetails:\r\n{1}", ex.Message, ex.ToString()), "Error in execution of Fourier transformation"); return; } }
/// <summary> /// Plots selected data columns of a table. /// </summary> /// <param name="table">The source table.</param> /// <param name="selectedColumns">The data columns of the table that should be plotted.</param> /// <param name="templatePlotStyle">The plot style which is the template for all plot items.</param> /// <param name="groupStyles">The group styles for the newly built plot item collection.</param> public static IGraphController Plot(DataTable table, IAscendingIntegerCollection selectedColumns, G2DPlotStyleCollection templatePlotStyle, PlotGroupStyleCollection groupStyles) { Altaxo.Graph.Gdi.GraphDocument graph = new Altaxo.Graph.Gdi.GraphDocument(); Altaxo.Graph.Gdi.XYPlotLayer layer = new Altaxo.Graph.Gdi.XYPlotLayer(graph.DefaultLayerPosition, graph.DefaultLayerSize); layer.CreateDefaultAxes(); graph.Layers.Add(layer); Current.Project.GraphDocumentCollection.Add(graph); return(Plot(table, selectedColumns, graph, templatePlotStyle, groupStyles)); }
/// <summary> /// Copies selected rows into newly created property columns and deletes the rows afterwards. /// </summary> /// <param name="table">Table which contains the data rows to change into property columns.</param> /// <param name="selectedDataRows">Indices of the rows to change.</param> /// <param name="selectedDataColumns">Indices of those columns which should be copies into the property column cells.</param> public static void ChangeRowsToPropertyColumns(this DataTable table, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns) { // first copy the rows into property columns foreach (var rowIdx in selectedDataRows) { var propColType = GetTypeOfColumnForRowReplacement(table.DataColumns, rowIdx, selectedDataColumns); var propCol = (DataColumn)Activator.CreateInstance(propColType); CopyRowToDataColumn(table.DataColumns, rowIdx, selectedDataColumns, propCol); table.PropCols.Add(propCol); } // now delete the rows table.DataColumns.RemoveRows(selectedDataRows); }
/// <summary> /// Exports to a single SPC spectrum from a single table column. /// </summary> /// <param name="filename">The name of the file where to export to.</param> /// <param name="table">The table from which to export.</param> /// <param name="columnnumber">The number of the table column that contains the data to export.</param> /// <param name="xcolumn">The x column that contains the x data.</param> /// <param name="selectedRows">The rows that where selected in the table, i.e. the rows which are exported. If this parameter is null /// or no rows are selected, then all data of a column will be exported.</param> /// <returns>Null if export was successfull, error description otherwise.</returns> public static string FromColumn( string filename, Altaxo.Data.DataTable table, int columnnumber, Altaxo.Data.INumericColumn xcolumn, IAscendingIntegerCollection selectedRows) { if (!(table.DataColumns[columnnumber] is Altaxo.Data.INumericColumn)) { return(string.Format("Table column[{0}] ({1}) is not a numeric column!", columnnumber, table.DataColumns[columnnumber].FullName)); } // test that all x and y cells have numeric values bool bUseSel = null != selectedRows && selectedRows.Count > 0; int spectrumlen = (bUseSel)? selectedRows.Count : table.DataColumns[columnnumber].Count; int i, j; for (j = 0; j < spectrumlen; j++) { i = bUseSel ? selectedRows[j] : j; if (xcolumn[i] == Double.NaN) { return(string.Format("X column at index {i} has no numeric value!", i)); } if (((Altaxo.Data.INumericColumn)table.DataColumns[columnnumber])[i] == Double.NaN) { return(string.Format("Table cell [{0},{1}] (column {2}) has no numeric value!", columnnumber, i, table.DataColumns[columnnumber].FullName)); } } // this first test was successfull, so start exporting now double[] xvalues = new double[spectrumlen]; double[] yvalues = new double[spectrumlen]; for (j = 0; j < spectrumlen; j++) { i = bUseSel ? selectedRows[j] : j; xvalues[j] = xcolumn[i]; yvalues[j] = ((Altaxo.Data.INumericColumn)table.DataColumns[columnnumber])[i]; } return(FromArrays(xvalues, yvalues, filename)); }
/// <summary> /// Adds to the destination table selected columns from another table. Additionally, the properties of those columns will be added to the destination table. /// </summary> /// <param name="destinationTable">Table where the columns should be added to.</param> /// <param name="tableToAddFrom">Source table.</param> /// <param name="selectedColumns">Indexes of the columns of the source table that should be added to the destination table.</param> public static void AddDataColumnsWithPropertiesFrom(this DataTable destinationTable, DataTable tableToAddFrom, IAscendingIntegerCollection selectedColumns) { IAscendingIntegerCollection mergedPropColsIndices = destinationTable.PropCols.MergeColumnTypesFrom(tableToAddFrom.PropCols); for (int i = 0; i < selectedColumns.Count; i++) { int sourceIdx = selectedColumns[i]; int destinationIdx = destinationTable.DataColumns.AppendCopiedColumnFrom(tableToAddFrom.DataColumns, sourceIdx, true, true); for (int j = 0; j < mergedPropColsIndices.Count; j++) { destinationTable.PropCols[mergedPropColsIndices[j]][destinationIdx] = tableToAddFrom.PropCols[j][sourceIdx]; } } }
/// <summary> /// Gets the indices of the data columns of the data table that contribute to the matrix. /// </summary> /// <returns>Indices of the participating data columns of the data table.</returns> /// <exception cref="InvalidDimensionMatrixException">No columns found that can be used for the matrix. Thus number of columns of the matrix would be zero.</exception> public IAscendingIntegerCollection GetParticipatingDataColumns() { if (null == _participatingDataColumns) { _participatingDataColumns = GetParticipatingDataColumns(_sourceTable, _selectedColumns); if (0 == _participatingDataColumns.Count) { throw new InvalidDimensionMatrixException("No columns found that can be used for the matrix. Thus number of columns of the matrix would be zero."); } _dataColumnsGroupNumber = _sourceTable.DataColumns.GetColumnGroup(_participatingDataColumns[0]); } return(_participatingDataColumns); }
/// <summary> /// Calculates the fitting values. /// </summary> /// <param name="parameter">The parameter used to calculate the values.</param> /// <param name="outputValues">You must provide an array to hold the calculated values. Size of the array must be /// at least <see cref="NumberOfData" />.</param> /// <param name="calculateUnusedDependentVariablesAlso">If <c>true</c>, the unused dependent variables are also calculated (and plotted).</param> /// <remarks>The values of the fit elements are stored in the order from element_0 to element_n. If there is more /// than one used dependent variable per fit element, the output values are stored in interleaved order. /// </remarks> public void EvaluateFitValues(double[] parameter, double[] outputValues, bool calculateUnusedDependentVariablesAlso) { int outputValuesPointer = 0; for (int ele = 0; ele < _cachedFitElementInfo.Length; ele++) { CachedFitElementInfo info = _cachedFitElementInfo[ele]; FitElement fitEle = _fitEnsemble[ele]; // copy of the parameter to the temporary array for (int i = 0; i < info.Parameters.Length; i++) { int idx = info.ParameterMapping[i]; info.Parameters[i] = idx >= 0 ? parameter[idx] : _constantParameters[-1 - idx]; } IAscendingIntegerCollection validRows = info.ValidRows; int numValidRows = validRows.Count; // Evaluate the function for all points for (int i = 0; i < numValidRows; ++i) { for (int k = info.Xs.Length - 1; k >= 0; k--) { info.Xs[k] = fitEle.IndependentVariables(k)[validRows[i]]; } fitEle.FitFunction.Evaluate(info.Xs, info.Parameters, info.Ys); if (calculateUnusedDependentVariablesAlso) { // copy the evaluation result to the output array (interleaved) for (int k = 0; k < fitEle.NumberOfDependentVariables; ++k) { outputValues[outputValuesPointer++] = info.Ys[k]; } } else { // copy the evaluation result to the output array (interleaved) for (int k = 0; k < info.DependentVariablesInUse.Length; ++k) { outputValues[outputValuesPointer++] = info.Ys[info.DependentVariablesInUse[k]]; } } } } }
public NumericTableRegionEnumerator(DataTable srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows) { _srctable = srctable; _selectedColumns = selectedColumns; _selectedRows = selectedRows; if (selectedColumns.Count == 0) { _selectedColumns = Altaxo.Collections.ContiguousIntegerRange.FromStartAndCount(0, srctable.DataColumns.ColumnCount); } if (selectedRows.Count == 0) { _selectedRows = Altaxo.Collections.ContiguousIntegerRange.FromStartAndCount(0, srctable.DataColumns.RowCount); } }
/// <summary> /// Merges two tables by fractional index. /// </summary> /// <param name="destinationTable">Table to merge into.</param> /// <param name="fractionalIndex">Array of fractional indices. Each item points into the slaveTable to the value that should be included in the master column at the item's index.</param> /// <param name="slaveTable">The table providing the data for merging into the master table.</param> /// <param name="slaveColumnsToMerge">Indices of that columns of the slave table that should be merged into the master table.</param> public static void MergeTable( this DataTable destinationTable, DoubleColumn fractionalIndex, DataTable slaveTable, IAscendingIntegerCollection slaveColumnsToMerge) { int destinationTableStartIdx = destinationTable.DataColumnCount; destinationTable.AddDataColumnsWithPropertiesFrom(slaveTable, slaveColumnsToMerge); for (int i = 0; i < slaveColumnsToMerge.Count; i++) { int slaveColIdx = slaveColumnsToMerge[i]; DataColumn newCol = destinationTable[destinationTableStartIdx + i]; SetColumnFromFractionalIndex(newCol, fractionalIndex, slaveTable[slaveColIdx]); } }
/// <summary> /// Makes a PCA (a principal component 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="bHorizontalOrientedSpectrum">True if a spectrum is a single row, False if a spectrum is a single column.</param> /// <param name="maxNumberOfFactors">The maximum number of factors to calculate.</param> /// <returns></returns> public static string PrincipalComponentAnalysis( Altaxo.AltaxoDocument mainDocument, Altaxo.Data.DataTable srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows, bool bHorizontalOrientedSpectrum, int maxNumberOfFactors ) { bool bUseSelectedColumns = (null!=selectedColumns && 0!=selectedColumns.Count); 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[i] is Altaxo.Data.INumericColumn) numcols++; } // check the number of rows bool bUseSelectedRows = (null!=selectedRows && 0!=selectedRows.Count); int numrows; if(bUseSelectedRows) numrows = selectedRows.Count; else { numrows = 0; for(int i=0;i<numcols;i++) { int idx = bUseSelectedColumns ? selectedColumns[i] : i; numrows = Math.Max(numrows,srctable[idx].Count); } } // check that both dimensions are at least 2 - otherwise PCA is not possible if(numrows<2) return "At least two rows are neccessary to do Principal Component Analysis!"; if(numcols<2) return "At least two numeric columns are neccessary to do Principal Component Analysis!"; // Create a matrix of appropriate dimensions and fill it MatrixMath.BEMatrix matrixX; if(bHorizontalOrientedSpectrum) { matrixX = new MatrixMath.BEMatrix(numrows,numcols); int ccol = 0; // current column in the matrix for(int i=0;i<prenumcols;i++) { int colidx = bUseSelectedColumns ? selectedColumns[i] : i; Altaxo.Data.INumericColumn col = srctable[colidx] as Altaxo.Data.INumericColumn; if(null!=col) { for(int j=0;j<numrows;j++) { int rowidx = bUseSelectedRows ? selectedRows[j] : j; matrixX[j,ccol] = col[rowidx]; } ++ccol; } } } // end if it was a horizontal oriented spectrum else // if it is a vertical oriented spectrum { matrixX = new MatrixMath.BEMatrix(numcols,numrows); int ccol = 0; // current column in the matrix for(int i=0;i<prenumcols;i++) { int colidx = bUseSelectedColumns ? selectedColumns[i] : i; Altaxo.Data.INumericColumn col = srctable[colidx] as Altaxo.Data.INumericColumn; if(null!=col) { for(int j=0;j<numrows;j++) { int rowidx = bUseSelectedRows ? selectedRows[j] : j; matrixX[ccol,j] = col[rowidx]; } ++ccol; } } } // if it was a vertical oriented spectrum // now do PCA with the matrix MatrixMath.REMatrix factors = new MatrixMath.REMatrix(0,0); MatrixMath.BEMatrix loads = new MatrixMath.BEMatrix(0,0); MatrixMath.BEMatrix residualVariances = new MatrixMath.BEMatrix(0,0); MatrixMath.HorizontalVector meanX = new MatrixMath.HorizontalVector(matrixX.Columns); // first, center the matrix MatrixMath.ColumnsToZeroMean(matrixX,meanX); MatrixMath.NIPALS_HO(matrixX,maxNumberOfFactors,1E-9,factors,loads,residualVariances); // 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 Altaxo.Data.DataTable table = new Altaxo.Data.DataTable("PCA of " + srctable.Name); // Fill the Table table.Suspend(); // first of all store the meanscore { double meanScore = MatrixMath.LengthOf(meanX); MatrixMath.NormalizeRows(meanX); Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for(int i=0;i<factors.Rows;i++) col[i] = meanScore; table.DataColumns.Add(col,"MeanFactor",Altaxo.Data.ColumnKind.V,0); } // first store the factors for(int i=0;i<factors.Columns;i++) { Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for(int j=0;j<factors.Rows;j++) col[j] = factors[j,i]; table.DataColumns.Add(col,"Factor"+i.ToString(),Altaxo.Data.ColumnKind.V,1); } // now store the mean of the matrix { Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for(int j=0;j<meanX.Columns;j++) col[j] = meanX[0,j]; table.DataColumns.Add(col,"MeanLoad",Altaxo.Data.ColumnKind.V,2); } // now store the loads - careful - they are horizontal in the matrix for(int i=0;i<loads.Rows;i++) { Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for(int j=0;j<loads.Columns;j++) col[j] = loads[i,j]; table.DataColumns.Add(col,"Load"+i.ToString(),Altaxo.Data.ColumnKind.V,3); } // now store the residual variances, they are vertical in the vector { Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for(int i=0;i<residualVariances.Rows;i++) col[i] = residualVariances[i,0]; table.DataColumns.Add(col,"ResidualVariance",Altaxo.Data.ColumnKind.V,4); } table.Resume(); mainDocument.DataTableCollection.Add(table); // create a new worksheet without any columns Current.ProjectService.CreateNewWorksheet(table); return null; }
/// <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; }
/// <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; }
public static bool ArePropertyCellsSelected(DataTable table, IAscendingIntegerCollection selectedPropertyColumns, IAscendingIntegerCollection selectedPropertyRows) { return table.PropCols.ColumnCount > 0 && (selectedPropertyColumns.Count > 0 || selectedPropertyRows.Count > 0); }
/// <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); var memento = GetContentAsMultivariateContentMemento(modelTable); // 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); } }
/// <summary> /// Adds to the destination table selected columns from another table. Additionally, the properties of those columns will be added to the destination table. /// </summary> /// <param name="destinationTable">Table where the columns should be added to.</param> /// <param name="tableToAddFrom">Source table.</param> /// <param name="selectedColumns">Indexes of the columns of the source table that should be added to the destination table.</param> public static void AddDataColumnsWithPropertiesFrom(this DataTable destinationTable, DataTable tableToAddFrom, IAscendingIntegerCollection selectedColumns) { IAscendingIntegerCollection mergedPropColsIndices = destinationTable.PropCols.MergeColumnTypesFrom(tableToAddFrom.PropCols); for (int i = 0; i < selectedColumns.Count; i++) { int sourceIdx = selectedColumns[i]; int destinationIdx = destinationTable.DataColumns.AppendCopiedColumnFrom(tableToAddFrom.DataColumns, sourceIdx, true, true); for (int j = 0; j < mergedPropColsIndices.Count; j++) { destinationTable.PropCols[mergedPropColsIndices[j]][destinationIdx] = tableToAddFrom.PropCols[j][sourceIdx]; } } }
/// <summary> /// Exports to a single SPC spectrum from a single table column. /// </summary> /// <param name="filename">The name of the file where to export to.</param> /// <param name="table">The table from which to export.</param> /// <param name="columnnumber">The number of the table column that contains the data to export.</param> /// <param name="xcolumn">The x column that contains the x data.</param> /// <param name="selectedRows">The rows that where selected in the table, i.e. the rows which are exported. If this parameter is null /// or no rows are selected, then all data of a column will be exported.</param> /// <returns>Null if export was successfull, error description otherwise.</returns> public static string FromColumn( string filename, Altaxo.Data.DataTable table, int columnnumber, Altaxo.Data.INumericColumn xcolumn, IAscendingIntegerCollection selectedRows) { if (!(table.DataColumns[columnnumber] is Altaxo.Data.INumericColumn)) return string.Format("Table column[{0}] ({1}) is not a numeric column!", columnnumber, table.DataColumns[columnnumber].FullName); // test that all x and y cells have numeric values bool bUseSel = null != selectedRows && selectedRows.Count > 0; int spectrumlen = (bUseSel) ? selectedRows.Count : table.DataColumns[columnnumber].Count; int i, j; for (j = 0; j < spectrumlen; j++) { i = bUseSel ? selectedRows[j] : j; if (double.IsNaN(xcolumn[i])) return string.Format("X column at index {i} has no numeric value!", i); if (((Altaxo.Data.INumericColumn)table.DataColumns[columnnumber])[i] == Double.NaN) return string.Format("Table cell [{0},{1}] (column {2}) has no numeric value!", columnnumber, i, table.DataColumns[columnnumber].FullName); } // this first test was successfull, so start exporting now double[] xvalues = new double[spectrumlen]; double[] yvalues = new double[spectrumlen]; for (j = 0; j < spectrumlen; j++) { i = bUseSel ? selectedRows[j] : j; xvalues[j] = xcolumn[i]; yvalues[j] = ((Altaxo.Data.INumericColumn)table.DataColumns[columnnumber])[i]; } return FromArrays(xvalues, yvalues, filename); }
/// <summary> /// Create a statistical table for statistics on columns. Property columns are not included in the statistical table. /// </summary> /// <param name="srcTable"></param> /// <param name="selectedColumns"></param> /// <returns></returns> private static DataTable CreateStatisticalTable(DataColumnCollection srcTable, IAscendingIntegerCollection selectedColumns) { DataTable result = new DataTable(); result.DataColumns.Add(new TextColumn(), DefaultColumnNameColumnName, ColumnKind.X, 0); AddStatisticColumns(result); return result; }
/// <summary> /// Paints part of the worksheet to the drawing context. Row and column header are always threaten as visible here. /// </summary> /// <param name="dc">Drawing context.</param> /// <param name="layout">Worksheet layout.</param> /// <param name="viewSize">Width and height of the viewing area (Pixel or Wpf coordinates).</param> /// <param name="clipRectangle">Bounds of the clipping region. Only that parts of the worksheet that are visible within the clipping region are drawn.</param> /// <param name="selectedDataColumns">Selected data columns.</param> /// <param name="selectedDataRows">Selected data rows.</param> /// <param name="selectedPropertyColumns">Selected property columns.</param> /// <param name="selectedPropertyRows">Selected property rows.</param> /// <param name="horzScrollPos">Horizontal scroll position (0 = first column visible).</param> /// <param name="vertScrollPos">Vertical scroll position (0 = first data column visible, negative values: one or more property columns visible).</param> public static void PaintTableArea( Graphics dc, Altaxo.Worksheet.WorksheetLayout layout, Size viewSize, RectangleD2D clipRectangle, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedPropertyColumns, IAscendingIntegerCollection selectedPropertyRows, int horzScrollPos, int vertScrollPos ) { var dataTable = layout.DataTable; bool bDrawColumnHeader = false; int firstTableRowToDraw = WA.GetFirstVisibleTableRow(clipRectangle.Top, layout, vertScrollPos); int numberOfTableRowsToDraw = WA.GetVisibleTableRows(clipRectangle.Top, clipRectangle.Bottom, layout, vertScrollPos); int firstPropertyColumnToDraw = WA.GetFirstVisiblePropertyColumn(clipRectangle.Top, layout, vertScrollPos); int numberOfPropertyColumnsToDraw = WA.GetVisiblePropertyColumns(clipRectangle.Top, clipRectangle.Bottom, layout, vertScrollPos); bool bAreColumnsSelected = selectedDataColumns.Count > 0; bool bAreRowsSelected = selectedDataRows.Count > 0; bool bAreCellsSelected = bAreRowsSelected || bAreColumnsSelected; bool bArePropertyColsSelected = selectedPropertyColumns.Count > 0; bool bArePropertyRowsSelected = selectedPropertyRows.Count > 0; bool bArePropertyCellsSelected = ArePropertyCellsSelected(dataTable, selectedPropertyColumns, selectedPropertyRows); int yShift = 0; var cellRectangle = new RectangleD2D(); double left, width; if (clipRectangle.Top < layout.ColumnHeaderStyle.Height) { bDrawColumnHeader = true; } // if neccessary, draw the row header (the most left column) if (clipRectangle.Left < layout.RowHeaderStyle.Width) { cellRectangle.Height = layout.ColumnHeaderStyle.Height; cellRectangle.Width = layout.RowHeaderStyle.Width; cellRectangle.X = 0; // if visible, draw the top left corner of the table if (bDrawColumnHeader) { cellRectangle.Y = 0; layout.RowHeaderStyle.PaintBackground(dc, (Rectangle)cellRectangle, false); } // if visible, draw property column header items yShift = WA.GetTopCoordinateOfPropertyColumn(firstPropertyColumnToDraw, layout, vertScrollPos); cellRectangle.Height = layout.PropertyColumnHeaderStyle.Height; for (int nPropCol = firstPropertyColumnToDraw, nInc = 0; nInc < numberOfPropertyColumnsToDraw; nPropCol++, nInc++) { cellRectangle.Y = yShift + nInc * layout.PropertyColumnHeaderStyle.Height; bool bPropColSelected = bArePropertyColsSelected && selectedPropertyColumns.Contains(nPropCol); layout.PropertyColumnHeaderStyle.Paint(dc, (Rectangle)cellRectangle, nPropCol, dataTable.PropCols[nPropCol], bPropColSelected); } } // draw the table row Header Items yShift = WA.GetTopCoordinateOfTableRow(firstTableRowToDraw, layout, vertScrollPos); cellRectangle.Height = layout.RowHeaderStyle.Height; for (int nRow = firstTableRowToDraw, nInc = 0; nInc < numberOfTableRowsToDraw; nRow++, nInc++) { cellRectangle.Y = yShift + nInc * layout.RowHeaderStyle.Height; layout.RowHeaderStyle.Paint(dc, (Rectangle)cellRectangle, nRow, null, bAreRowsSelected && selectedDataRows.Contains(nRow)); } if (clipRectangle.Bottom >= layout.ColumnHeaderStyle.Height || clipRectangle.Right >= layout.RowHeaderStyle.Width) { int numberOfColumnsToDraw; int firstColToDraw = WA.GetFirstAndNumberOfVisibleColumn(clipRectangle.Left, clipRectangle.Right, layout, horzScrollPos, out numberOfColumnsToDraw); // draw the property columns for (int nPropCol = firstPropertyColumnToDraw, nIncPropCol = 0; nIncPropCol < numberOfPropertyColumnsToDraw; nPropCol++, nIncPropCol++) { Altaxo.Worksheet.ColumnStyle cs = layout.PropertyColumnStyles[dataTable.PropCols[nPropCol]]; bool bPropColSelected = bArePropertyColsSelected && selectedPropertyColumns.Contains(nPropCol); bool bPropColIncluded = bArePropertyColsSelected ? bPropColSelected : true; // Property cells are only included if the column is explicite selected cellRectangle.Y = WA.GetTopCoordinateOfPropertyColumn(nPropCol, layout, vertScrollPos); cellRectangle.Height = layout.PropertyColumnHeaderStyle.Height; for (int nCol = firstColToDraw, nIncCol = 0; nIncCol < numberOfColumnsToDraw; nCol++, nIncCol++) { if (nCol == firstColToDraw) { WA.GetXCoordinatesOfColumn(nCol, layout, horzScrollPos, out left, out width); cellRectangle.X = left; cellRectangle.Width = width; } else { cellRectangle.X += cellRectangle.Width; cellRectangle.Width = layout.DataColumnStyles[dataTable.DataColumns[nCol]].WidthD; } bool bPropRowSelected = bArePropertyRowsSelected && selectedPropertyRows.Contains(nCol); bool bPropRowIncluded = bArePropertyRowsSelected ? bPropRowSelected : true; cs.Paint(dc, (Rectangle)cellRectangle, nCol, dataTable.PropCols[nPropCol], bArePropertyCellsSelected && bPropColIncluded && bPropRowIncluded); } } // draw the cells for (int nCol = firstColToDraw, nIncCol = 0; nIncCol < numberOfColumnsToDraw; nCol++, nIncCol++) { Altaxo.Worksheet.ColumnStyle cs = layout.DataColumnStyles[dataTable.DataColumns[nCol]]; if (nCol == firstColToDraw) { WA.GetXCoordinatesOfColumn(nCol, layout, horzScrollPos, out left, out width); cellRectangle.X = left; cellRectangle.Width = width; } else { cellRectangle.X += cellRectangle.Width; cellRectangle.Width = cs.WidthD; } bool bColumnSelected = bAreColumnsSelected && selectedDataColumns.Contains(nCol); bool bDataColumnIncluded = bAreColumnsSelected ? bColumnSelected : true; bool bPropertyRowSelected = bArePropertyRowsSelected && selectedPropertyRows.Contains(nCol); if (bDrawColumnHeader) // must the column Header been drawn? { cellRectangle.Height = layout.ColumnHeaderStyle.Height; cellRectangle.Y = 0; layout.ColumnHeaderStyle.Paint(dc, (Rectangle)cellRectangle, 0, dataTable[nCol], bColumnSelected || bPropertyRowSelected); } yShift = WA.GetTopCoordinateOfTableRow(firstTableRowToDraw, layout, vertScrollPos); cellRectangle.Height = layout.RowHeaderStyle.Height; for (int nRow = firstTableRowToDraw, nIncRow = 0; nIncRow < numberOfTableRowsToDraw; nRow++, nIncRow++) { bool bRowSelected = bAreRowsSelected && selectedDataRows.Contains(nRow); bool bDataRowIncluded = bAreRowsSelected ? bRowSelected : true; cellRectangle.Y = yShift + nIncRow * layout.RowHeaderStyle.Height; cs.Paint(dc, (Rectangle)cellRectangle, nRow, dataTable[nCol], bAreCellsSelected && bDataColumnIncluded && bDataRowIncluded); } } } }
public MultivariateLinearFitParameters(DataColumnCollection table, IAscendingIntegerCollection selectedDataColumns) { _table = table; _selectedDataColumns = selectedDataColumns; }
/// <summary> /// Calculates statistics of selected columns. Creates a new table where the statistical data will be written to. /// </summary> /// <param name="srctable">Source table.</param> /// <param name="selectedColumns">Selected data columns in the source table.</param> /// <param name="selectedRows">Selected rows in the source table.</param> /// <param name="destinationTable">The table where the statistical results are written to.</param> public static void DoStatisticsOnRows( this DataColumnCollection srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows, DataColumnCollection destinationTable ) { bool bUseSelectedColumns = (null != selectedColumns && 0 != selectedColumns.Count); int numcols = bUseSelectedColumns ? selectedColumns.Count : srctable.ColumnCount; if (numcols == 0) return; // nothing selected bool bUseSelectedRows = (null != selectedRows && 0 != selectedRows.Count); int numrows = bUseSelectedRows ? selectedRows.Count : srctable.RowCount; if (numrows == 0) return; Data.DoubleColumn cRows = new DoubleColumn(); // 1st column is the mean, and holds the sum during the calculation Data.DoubleColumn colMean = new Data.DoubleColumn(); // 2rd column is the standard deviation, and holds the square sum during calculation Data.DoubleColumn colSD = new Data.DoubleColumn(); // 3th column is the standard e (N) Data.DoubleColumn colSE = new Data.DoubleColumn(); // 4th column is the sum Data.DoubleColumn colSum = new Data.DoubleColumn(); // 5th column is the number of items for statistics Data.DoubleColumn colNN = new Data.DoubleColumn(); var colSumSqr = new Data.DoubleColumn(); var colFracOneSigma = new Data.DoubleColumn(); var colFracTwoSigma = new Data.DoubleColumn(); var colFracThreeSigma = new Data.DoubleColumn(); var colMinimum = new DoubleColumn(); var colMaximum = new DoubleColumn(); // first fill the cols c1, c2, c5 with zeros because we want to sum up for (int i = 0; i < numrows; i++) { colSum[i] = 0; colSumSqr[i] = 0; colNN[i] = 0; colMinimum[i] = double.PositiveInfinity; colMaximum[i] = double.NegativeInfinity; } for (int si = 0; si < numcols; si++) { Altaxo.Data.DataColumn col = bUseSelectedColumns ? srctable[selectedColumns[si]] : srctable[si]; if (!(col is Altaxo.Data.INumericColumn)) continue; // now do the statistics Data.INumericColumn ncol = (Data.INumericColumn)col; for (int i = 0; i < numrows; i++) { int row = bUseSelectedRows ? selectedRows[i] : i; cRows[i] = row; double val = ncol[row]; if (Double.IsNaN(val)) continue; colSum[i] += val; colSumSqr[i] += val * val; colNN[i] += 1; colMinimum[i] = Math.Min(colMinimum[i], val); colMaximum[i] = Math.Max(colMaximum[i], val); } } // for all selected columns // now calculate the statistics for (int i = 0; i < numrows; i++) { // now fill a new row in the worksheet double NN = colNN[i]; double sum = colSum[i]; double sumsqr = colSumSqr[i]; if (NN > 0) { double mean = sum / NN; double ymy0sqr = sumsqr - sum * sum / NN; if (ymy0sqr < 0) ymy0sqr = 0; // if this is lesser zero, it is a rounding error, so set it to zero double sd = NN > 1 ? Math.Sqrt(ymy0sqr / (NN - 1)) : 0; double se = sd / Math.Sqrt(NN); colMean[i] = mean; // mean colSD[i] = sd; colSE[i] = se; } else { colMinimum[i] = double.NaN; colMaximum[i] = double.NaN; } } // for all rows // calculate fractions for (int i = 0; i < numrows; i++) { int row = bUseSelectedRows ? selectedRows[i] : i; double mean = colMean[i]; double sd = colSD[i]; // calculate fractions double oneSigmaLo = mean - 1 * sd, oneSigmaHi = mean + 1 * sd; double twoSigmaLo = mean - 2 * sd, twoSigmaHi = mean + 2 * sd; double threeSigmaLo = mean - 3 * sd, threeSigmaHi = mean + 3 * sd; int cntOneSigma = 0, cntTwoSigma = 0, cntThreeSigma = 0; for (int si = 0; si < numcols; si++) { Altaxo.Data.DataColumn col = bUseSelectedColumns ? srctable[selectedColumns[si]] : srctable[si]; if (!(col is Altaxo.Data.INumericColumn)) continue; // now do the statistics Data.INumericColumn ncol = (Data.INumericColumn)col; double val = ncol[row]; if (Double.IsNaN(val)) continue; if (Altaxo.Calc.RMath.IsInIntervalCC(val, oneSigmaLo, oneSigmaHi)) ++cntOneSigma; if (Altaxo.Calc.RMath.IsInIntervalCC(val, twoSigmaLo, twoSigmaHi)) ++cntTwoSigma; if (Altaxo.Calc.RMath.IsInIntervalCC(val, threeSigmaLo, threeSigmaHi)) ++cntThreeSigma; } colFracOneSigma[i] = cntOneSigma / (double)colNN[i]; colFracTwoSigma[i] = cntTwoSigma / (double)colNN[i]; colFracThreeSigma[i] = cntThreeSigma / (double)colNN[i]; } destinationTable.EnsureExistence(DefaultRowNumberColumnName, typeof(DoubleColumn), ColumnKind.X, 0).Append(cRows); AppendStatisticalData(destinationTable, colMean, colSD, colSE, colSum, colSumSqr, colNN, colFracOneSigma, colFracTwoSigma, colFracThreeSigma, colMinimum, colMaximum); }
public static LinearFitBySvd ShowDialogAndRegress(DataColumnCollection table, IAscendingIntegerCollection selectedColumns) { if(selectedColumns.Count<2) return null; object paramobject = new MultivariateLinearFitParameters(table,selectedColumns); if(!Current.Gui.ShowDialog(ref paramobject,"Multivariate linear fit")) return null; MultivariateLinearFitParameters parameters = (MultivariateLinearFitParameters)paramobject; LinearFitBySvd result = Regress(parameters, true); return result; }
/// <summary> /// Remove the selected data columns <b>and the corresponding property rows</b>. /// </summary> /// <param name="selectedColumns">A collection of the indizes to the columns that have to be removed.</param> public virtual void RemoveColumns(IAscendingIntegerCollection selectedColumns) { Suspend(); _dataColumns.RemoveColumns(selectedColumns); // remove the columns from the collection _propertyColumns.RemoveRows(selectedColumns); // remove also the corresponding rows from the Properties Resume(); }
/// <summary> /// Creates the controller for the Galactic SPC file export dialog. /// </summary> /// <param name="table">The data table which is about to be exported.</param> /// <param name="selectedRows">The selected rows of the data table.</param> /// <param name="selectedColumns">The selected columns of the data table.</param> public ExportGalacticSpcFileDialogController( Altaxo.Data.DataTable table, IAscendingIntegerCollection selectedRows, IAscendingIntegerCollection selectedColumns) { m_Table = table; m_SelectedRows = selectedRows; m_SelectedColumns = selectedColumns; InitializeElements(); }
/// <summary> /// Multiplies selected columns to form a matrix. /// </summary> /// <param name="mainDocument"></param> /// <param name="srctable"></param> /// <param name="selectedColumns"></param> /// <returns>Null if successful, else the description of the error.</returns> /// <remarks>The user must select an even number of columns. All columns of the first half of the selection /// must have the same number of rows, and all columns of the second half of selection must also have the same /// number of rows. The first half of selected columns form a matrix of dimensions(firstrowcount,halfselected), and the second half /// of selected columns form a matrix of dimension(halfselected, secondrowcount). The resulting matrix has dimensions (firstrowcount,secondrowcount) and is /// stored in a separate worksheet.</remarks> public static string MultiplyColumnsToMatrix( Altaxo.AltaxoDocument mainDocument, Altaxo.Data.DataTable srctable, IAscendingIntegerCollection selectedColumns ) { // check that there are columns selected if(0==selectedColumns.Count) return "You must select at least two columns to multiply!"; // selected columns must contain an even number of columns if(0!=selectedColumns.Count%2) return "You selected an odd number of columns. Please select an even number of columns to multiply!"; // all selected columns must be numeric columns for(int i=0;i<selectedColumns.Count;i++) { if(!(srctable[selectedColumns[i]] is Altaxo.Data.INumericColumn)) return string.Format("The column[{0}] (name:{1}) is not a numeric column!",selectedColumns[i],srctable[selectedColumns[i]].Name); } int halfselect = selectedColumns.Count/2; // check that all columns from the first half of selected colums contain the same // number of rows int rowsfirsthalf=int.MinValue; for(int i=0;i<halfselect;i++) { int idx = selectedColumns[i]; if(rowsfirsthalf<0) rowsfirsthalf = srctable[idx].Count; else if(rowsfirsthalf != srctable[idx].Count) return "The first half of selected columns have not all the same length!"; } int rowssecondhalf=int.MinValue; for(int i=halfselect;i<selectedColumns.Count;i++) { int idx = selectedColumns[i]; if(rowssecondhalf<0) rowssecondhalf = srctable[idx].Count; else if(rowssecondhalf != srctable[idx].Count) return "The second half of selected columns have not all the same length!"; } // now create the matrices to multiply from the MatrixMath.REMatrix firstMat = new MatrixMath.REMatrix(rowsfirsthalf,halfselect); for(int i=0;i<halfselect;i++) { Altaxo.Data.INumericColumn col = (Altaxo.Data.INumericColumn)srctable[selectedColumns[i]]; for(int j=0;j<rowsfirsthalf;j++) firstMat[j,i] = col[j]; } MatrixMath.BEMatrix secondMat = new MatrixMath.BEMatrix(halfselect,rowssecondhalf); for(int i=0;i<halfselect;i++) { Altaxo.Data.INumericColumn col = (Altaxo.Data.INumericColumn)srctable[selectedColumns[i+halfselect]]; for(int j=0;j<rowssecondhalf;j++) secondMat[i,j] = col[j]; } // now multiply the two matrices MatrixMath.BEMatrix resultMat = new MatrixMath.BEMatrix(rowsfirsthalf,rowssecondhalf); MatrixMath.Multiply(firstMat,secondMat,resultMat); // and store the result in a new worksheet Altaxo.Data.DataTable table = new Altaxo.Data.DataTable("ResultMatrix of " + srctable.Name); table.Suspend(); // first store the factors for(int i=0;i<resultMat.Columns;i++) { Altaxo.Data.DoubleColumn col = new Altaxo.Data.DoubleColumn(); for(int j=0;j<resultMat.Rows;j++) col[j] = resultMat[j,i]; table.DataColumns.Add(col,i.ToString()); } table.Resume(); mainDocument.DataTableCollection.Add(table); // create a new worksheet without any columns Current.ProjectService.CreateNewWorksheet(table); return null; }
public static void ShowDecomposeByColumnContentDialog(this DataTable srcTable, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns) { DataTableMultipleColumnProxy proxy = null; DecomposeByColumnContentOptions options = null; try { proxy = new DataTableMultipleColumnProxy(DecomposeByColumnContentDataAndOptions.ColumnsParticipatingIdentifier, srcTable, selectedDataRows, selectedDataColumns); proxy.EnsureExistenceOfIdentifier(DecomposeByColumnContentDataAndOptions.ColumnWithCyclingVariableIdentifier, 1); options = new DecomposeByColumnContentOptions(); } catch (Exception ex) { Current.Gui.ErrorMessageBox(string.Format("{0}\r\nDetails:\r\n{1}", ex.Message, ex.ToString()), "Error in preparation of 'Decompose by column content'"); return; } var dataAndOptions = new DecomposeByColumnContentDataAndOptions(proxy, options); // in order to show the column names etc in the dialog, it is neccessary to set the source if (true == Current.Gui.ShowDialog(ref dataAndOptions, "Choose options", false)) { var destTable = new DataTable(); proxy = dataAndOptions.Data; options = dataAndOptions.Options; string error = null; try { error = DecomposeByColumnContent(dataAndOptions.Data, dataAndOptions.Options, destTable); } catch (Exception ex) { error = ex.ToString(); } if (null != error) Current.Gui.ErrorMessageBox(error); destTable.Name = srcTable.Name + "_Decomposed"; // Create a DataSource var dataSource = new DecomposeByColumnContentDataSource(proxy, options, new Altaxo.Data.DataSourceImportOptions()); destTable.DataSource = dataSource; Current.Project.DataTableCollection.Add(destTable); Current.ProjectService.ShowDocumentView(destTable); } }
/// <summary> /// This is neccessary to use the dialog. /// </summary> /// <param name="table">The table which contains the data to export.</param> /// <param name="selectedRows">The rows selected in the table.</param> /// <param name="selectedColumns">The columns selected in the table.</param> public void Initialize(Altaxo.Data.DataTable table, IAscendingIntegerCollection selectedRows, IAscendingIntegerCollection selectedColumns) { m_Controller = new ExportGalacticSpcFileDialogController(this,table,selectedRows,selectedColumns); }
/// <summary> /// Maps each data column of the source table to a corresponding data columns of the destination table. /// The matching is based on the index (order) and on the currently selected columns of the destination table. /// Attention: The match here does <b>not</b> mean that the two columns are data compatible to each other! /// </summary> /// <param name="desttable">The destination table.</param> /// <param name="selectedDestColumns">The currently selected columns of the destination table.</param> /// <param name="sourcetable">The source table.</param> /// <returns>An array of columns. Each column of the array is a data column in the destination table, which /// matches (by index) the data column in the source table.</returns> /// <remarks> /// 1.) Since the returned columns are part of the DataColumns collection of the destination table, you must not /// use these for inserting i.e. in other tables. /// 2.) The match is based on the index and the selected columns of the destination table. The rules are as follows: if there is /// no selection, the first column of the destination table matches the first column of the source table, and so forth. /// If there is a column selection, the first selected column of the destination table matches the first column of the source table, /// the second selected column of the destination table matches the second column of the source table. If more source columns than selected columns in the destination /// table exists, the match is done 1:1 after the last selected column of the destination table. If there is no further column in the destination /// table to match, new columns are created in the destination table. /// </remarks> static protected Altaxo.Data.DataColumn[] MapOrCreateDataColumns(Altaxo.Data.DataTable desttable, IAscendingIntegerCollection selectedDestColumns, Altaxo.Data.DataTable sourcetable) { Altaxo.Data.DataColumn[] columnmap = new Altaxo.Data.DataColumn[sourcetable.DataColumns.ColumnCount]; int nDestCol = -1; for (int nCol = 0; nCol < sourcetable.DataColumns.ColumnCount; nCol++) { nDestCol = nCol < selectedDestColumns.Count ? selectedDestColumns[nCol] : nDestCol + 1; string name = sourcetable.DataColumns.GetColumnName(nCol); int group = sourcetable.DataColumns.GetColumnGroup(nCol); Altaxo.Data.ColumnKind kind = sourcetable.DataColumns.GetColumnKind(nCol); if (nDestCol < desttable.DataColumns.ColumnCount) { columnmap[nCol] = desttable.DataColumns[nDestCol]; } else { columnmap[nCol] = (DataColumn)Activator.CreateInstance(sourcetable.DataColumns[nCol].GetType()); desttable.DataColumns.Add(columnmap[nCol], name, kind, group); } } return columnmap; }
public XYZMeshedColumnPlotData(DataTable table, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedPropertyColumns) { _matrixProxy = new DataTableMatrixProxy(table, selectedDataRows, selectedDataColumns, selectedPropertyColumns) { ParentObject = this }; this.SetXBoundsFromTemplate(new FiniteNumericalBoundaries()); this.SetYBoundsFromTemplate(new FiniteNumericalBoundaries()); this.SetVBoundsFromTemplate(new FiniteNumericalBoundaries()); }
/// <summary> /// Constructor. Besides the table, the current selections must be provided. Only the areas that corresponds to the selections are /// serialized. The serialization process has to occur immediately after this constructor, because only a reference /// to the table is hold by this object. /// </summary> /// <param name="table">The table to serialize.</param> /// <param name="selectedDataColumns">The selected data columns.</param> /// <param name="selectedDataRows">The selected data rows.</param> /// <param name="selectedPropertyColumns">The selected property columns.</param> /// <param name="selectedPropertyRows">The selected property rows.</param> public ClipboardMemento(DataTable table, IAscendingIntegerCollection selectedDataColumns, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedPropertyColumns, IAscendingIntegerCollection selectedPropertyRows ) { this._table = table; this._selectedDataColumns = selectedDataColumns; this._selectedDataRows = selectedDataRows; this._selectedPropertyColumns = selectedPropertyColumns; this._selectedPropertyRows = selectedPropertyRows; }
/// <summary> /// Creates a table for statistics on columns. Property columns are included in the statistical table. /// </summary> /// <param name="srcTable"></param> /// <param name="selectedColumns"></param> /// <returns></returns> private static DataTable CreateStatisticalTable(DataTable srcTable, IAscendingIntegerCollection selectedColumns) { DataTable result = new DataTable(); result.Name = Altaxo.Main.ProjectFolder.PrependToName(srcTable.Name, "Statistics of "); result.DataColumns.Add(new TextColumn(), DefaultColumnNameColumnName, ColumnKind.X, 0); AddSourcePropertyColumns(srcTable, selectedColumns, result); AddStatisticColumns(result); return result; }
/// <summary> /// Shows the dialog for Galactic SPC file export, and exports the data of the table using the options provided in that dialog. /// </summary> /// <param name="dataTable">DataTable to export.</param> /// <param name="selectedDataRows">Rows to export (can be null - then all rows will be considered for export).</param> /// <param name="selectedDataColumns">Columns to export (can be null - then all columns will be considered for export).</param> public static void ShowExportGalacticSPCDialog(this DataTable dataTable, IAscendingIntegerCollection selectedDataRows, IAscendingIntegerCollection selectedDataColumns) { var exportCtrl = new Altaxo.Gui.Worksheet.ExportGalacticSpcFileDialogController(dataTable, selectedDataRows, selectedDataColumns); Current.Gui.ShowDialog(exportCtrl, "Export Galactic SPC format"); }
private static void AddSourcePropertyColumns(DataTable srctable, IAscendingIntegerCollection selectedColumns, DataTable destinationTable) { bool bUseSelectedColumns = (null != selectedColumns && 0 != selectedColumns.Count); int numcols = bUseSelectedColumns ? selectedColumns.Count : srctable.DataColumnCount; // new : add a copy of all property columns; can be usefull for (int i = 0; i < srctable.PropertyColumnCount; i++) { DataColumn originalColumn = srctable.PropertyColumns[i]; DataColumn clonedColumn = (DataColumn)originalColumn.Clone(); clonedColumn.Clear(); for (int si = 0; si < numcols; si++) { int idx = bUseSelectedColumns ? selectedColumns[si] : si; clonedColumn[si] = originalColumn[idx]; } destinationTable.DataColumns.Add(clonedColumn, srctable.PropertyColumns.GetColumnName(i), srctable.PropertyColumns.GetColumnKind(i), srctable.PropertyColumns.GetColumnGroup(i)); } }
/// <summary> /// This is neccessary to use the dialog. /// </summary> /// <param name="table">The table which contains the data to export.</param> /// <param name="selectedRows">The rows selected in the table.</param> /// <param name="selectedColumns">The columns selected in the table.</param> public void Initialize(Altaxo.Data.DataTable table, IAscendingIntegerCollection selectedRows, IAscendingIntegerCollection selectedColumns) { }
/// <summary> /// Calculates statistics of selected columns. Creates a new table where the statistical data will be written to. /// </summary> /// <param name="srctable">Source table.</param> /// <param name="selectedColumns">Selected data columns in the source table. If the argument is null, all columns will be used.</param> /// <param name="selectedRows">Selected rows in the source table. If the argument is null, all rows will be used.</param> /// <param name="destinationTable">The table where the statistical results are written to.</param> public static void DoStatisticsOnColumns( this DataColumnCollection srctable, IAscendingIntegerCollection selectedColumns, IAscendingIntegerCollection selectedRows, DataColumnCollection destinationTable ) { bool bUseSelectedColumns = (null != selectedColumns && 0 != selectedColumns.Count); int numcols = bUseSelectedColumns ? selectedColumns.Count : srctable.ColumnCount; bool bUseSelectedRows = (null != selectedRows && 0 != selectedRows.Count); if (numcols == 0) return; // nothing selected // add a text column and some double columns // note: statistics is only possible for numeric columns since // otherwise in one column doubles and i.e. dates are mixed, which is not possible // 1st column is the name of the column of which the statistics is made Data.TextColumn colCol = new Data.TextColumn(); // 2nd column is the mean Data.DoubleColumn colMean = new Data.DoubleColumn(); // 3rd column is the standard deviation Data.DoubleColumn colSd = new Data.DoubleColumn(); // 4th column is the standard e (N) Data.DoubleColumn colSe = new Data.DoubleColumn(); // 5th column is the sum Data.DoubleColumn colSum = new Data.DoubleColumn(); var colSumSqr = new Data.DoubleColumn(); // 6th column is the number of items for statistics Data.DoubleColumn colN = new Data.DoubleColumn(); var colFracOneSigma = new Data.DoubleColumn(); var colFracTwoSigma = new Data.DoubleColumn(); var colFracThreeSigma = new Data.DoubleColumn(); var colMinimum = new DoubleColumn(); // Minimum of the values var colMaximum = new DoubleColumn(); // Maximum of the values int currRow = 0; for (int si = 0; si < numcols; si++) { Altaxo.Data.DataColumn col = bUseSelectedColumns ? srctable[selectedColumns[si]] : srctable[si]; if (!(col is Altaxo.Data.INumericColumn)) continue; int rows = bUseSelectedRows ? selectedRows.Count : srctable.RowCount; if (rows == 0) continue; // now do the statistics Data.INumericColumn ncol = (Data.INumericColumn)col; double sum = 0; double sumsqr = 0; int NN = 0; double minimum = double.PositiveInfinity; double maximum = double.NegativeInfinity; for (int i = 0; i < rows; i++) { double val = bUseSelectedRows ? ncol[selectedRows[i]] : ncol[i]; if (Double.IsNaN(val)) continue; NN++; sum += val; sumsqr += (val * val); minimum = Math.Min(minimum, val); maximum = Math.Max(maximum, val); } // now fill a new row in the worksheet double mean = sum / NN; double ymy0sqr = sumsqr - sum * sum / NN; if (ymy0sqr < 0) ymy0sqr = 0; // if this is lesser zero, it is a rounding error, so set it to zero double sd = NN > 1 ? Math.Sqrt(ymy0sqr / (NN - 1)) : 0; double se = sd / Math.Sqrt(NN); // calculate fractions double oneSigmaLo = mean - 1 * sd, oneSigmaHi = mean + 1 * sd; double twoSigmaLo = mean - 2 * sd, twoSigmaHi = mean + 2 * sd; double threeSigmaLo = mean - 3 * sd, threeSigmaHi = mean + 3 * sd; int cntOneSigma = 0, cntTwoSigma = 0, cntThreeSigma = 0; for (int i = 0; i < rows; i++) { double val = bUseSelectedRows ? ncol[selectedRows[i]] : ncol[i]; if (Double.IsNaN(val)) continue; if (Altaxo.Calc.RMath.IsInIntervalCC(val, oneSigmaLo, oneSigmaHi)) ++cntOneSigma; if (Altaxo.Calc.RMath.IsInIntervalCC(val, twoSigmaLo, twoSigmaHi)) ++cntTwoSigma; if (Altaxo.Calc.RMath.IsInIntervalCC(val, threeSigmaLo, threeSigmaHi)) ++cntThreeSigma; } if (0 == NN) { minimum = maximum = double.NaN; } colCol[currRow] = col.Name; colMean[currRow] = mean; // mean colSd[currRow] = sd; colSe[currRow] = se; colSum[currRow] = sum; colSumSqr[currRow] = sumsqr; colN[currRow] = NN; colFracOneSigma[currRow] = cntOneSigma / (double)NN; colFracTwoSigma[currRow] = cntTwoSigma / (double)NN; colFracThreeSigma[currRow] = cntThreeSigma / (double)NN; colMinimum[currRow] = minimum; colMaximum[currRow] = maximum; currRow++; // for the next column } // for all selected columns if (currRow != 0) { destinationTable.EnsureExistence(DefaultColumnNameColumnName, typeof(TextColumn), ColumnKind.X, 0).Append(colCol); AppendStatisticalData(destinationTable, colMean, colSd, colSe, colSum, colSumSqr, colN, colFracOneSigma, colFracTwoSigma, colFracThreeSigma, colMinimum, colMaximum); } }
/// <summary> /// Maps each data column of the source table to a corresponding data row (!) of the destination table. /// The matching is based on the index (order) and on the currently selected columns of the destination table. /// Attention: The match here does <b>not</b> mean that the data of destination columns and source rows are compatible to each other! /// </summary> /// <param name="desttable">The destination table.</param> /// <param name="selectedDestColumns">The currently selected columns of the destination table.</param> /// <param name="sourcetable">The source table.</param> /// <returns>An array of columns. Each column of the array is a data column in the destination table, which /// matches (by index) the data row (!) in the source table with the same index.</returns> /// <remarks> /// 1.) Since the returned columns are part of the DataColumns collection of the destination table, you must not /// use these for inserting i.e. in other tables. /// 2.) The match is based on the index and the selected columns of the destination table. The rules are as follows: if there is /// no selection, the first column of the destination table matches the first row of the source table, and so forth. /// If there is a column selection, the first selected column of the destination table matches the first row of the source table, /// the second selected column of the destination table matches the second row of the source table. If there are more source rows than selected columns in the destination /// table exists, the match is done 1:1 after the last selected column of the destination table. If there is no further column in the destination /// table to match, new columns are created in the destination table. The type of the newly created columns in the destination table is /// the same as the first column of the source table in this case. /// </remarks> static protected Altaxo.Data.DataColumn[] MapOrCreateDataColumnsToRows(Altaxo.Data.DataTable desttable, IAscendingIntegerCollection selectedDestColumns, Altaxo.Data.DataTable sourcetable) { Altaxo.Data.DataColumn[] columnmap = new Altaxo.Data.DataColumn[sourcetable.DataColumns.RowCount]; int nDestCol = -1; int group = 0; for (int nCol = 0; nCol < sourcetable.DataColumns.RowCount; nCol++) { nDestCol = nCol < selectedDestColumns.Count ? selectedDestColumns[nCol] : nDestCol + 1; if (nDestCol < desttable.DataColumns.ColumnCount) { group = desttable.DataColumns.GetColumnGroup(nDestCol); // we preserve the group of the last existing column for creation of new columns columnmap[nCol] = desttable.DataColumns[nDestCol]; } else { columnmap[nCol] = (DataColumn)Activator.CreateInstance(sourcetable.DataColumns[0].GetType()); desttable.DataColumns.Add(columnmap[nCol], desttable.DataColumns.FindNewColumnName(), ColumnKind.V, group); } } return columnmap; }