public void Init(Parameters parameters1, float paramNameWidth, int totalWidth)
{
Parameters = parameters1;
int nrows = Parameters.GroupCount;
parameterGroupPanels = new ParameterGroupPanel[nrows];
tableLayoutPanel = new TableLayoutPanel();
SuspendLayout();
tableLayoutPanel.ColumnCount = 1;
tableLayoutPanel.ColumnStyles.Clear();
tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
tableLayoutPanel.Dock = DockStyle.None;
tableLayoutPanel.Location = new Point(0, 0);
tableLayoutPanel.Name = "tableLayoutPanel";
tableLayoutPanel.RowCount = nrows + 1;
tableLayoutPanel.RowStyles.Clear();
float totalHeight = 0;
for (int i = 0; i < nrows; i++){
float h = parameters1.GetGroup(i).Height + 26;
tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.AutoSize, h));
totalHeight += h + 6;
}
tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
tableLayoutPanel.Size = new Size(totalWidth, (int) totalHeight);
tableLayoutPanel.TabIndex = 0;
for (int i = 0; i < nrows; i++){
AddParameterGroup(parameters1.GetGroup(i), i, paramNameWidth, totalWidth);
}
AutoScaleDimensions = new SizeF(6F, 13F);
AutoScaleMode = AutoScaleMode.Font;
Controls.Clear();
Controls.Add(tableLayoutPanel);
Name = "ParameterPanel";
Size = new Size(totalWidth, (int) totalHeight);
ResumeLayout(true);
}
public BoolWithSubParams(string name, bool value)
: base(name)
{
Value = value;
Default = value;
SubParamsFalse = new Parameters();
SubParamsTrue = new Parameters();
}
private static void AddIntSubParams(ICollection<IntParam> result, Parameters sp)
{
foreach (Parameter p in sp.GetAllParameters()){
if (p is IntParam){
result.Add((IntParam) p);
} else if (p is ParameterWithSubParams){
AddIntSubParams(result, ((ParameterWithSubParams) p).GetSubParameters());
}
}
}
public static void FilterRows(IMatrixData mdata, Parameters parameters, int[] rows)
{
bool reduceMatrix = GetReduceMatrix(parameters);
if (reduceMatrix){
mdata.ExtractExpressionRows(rows);
} else{
Array.Sort(rows);
string[][] col = new string[mdata.RowCount][];
for (int i = 0; i < col.Length; i++){
bool contains = Array.BinarySearch(rows, i) >= 0;
col[i] = contains ? new[]{"Keep"} : new[]{"Discard"};
}
mdata.AddCategoryColumn("Filter", "", col);
}
}
public static void FilterColumns(IMatrixData mdata, Parameters parameters, int[] cols)
{
bool reduceMatrix = GetReduceMatrix(parameters);
if (reduceMatrix){
mdata.ExtractExpressionColumns(cols);
} else{
Array.Sort(cols);
string[][] row = new string[mdata.ExpressionColumnCount][];
for (int i = 0; i < row.Length; i++){
bool contains = Array.BinarySearch(cols, i) >= 0;
row[i] = contains ? new[]{"Keep"} : new[]{"Discard"};
}
mdata.AddCategoryRow("Filter", "", row);
}
}
public ParameterForm(Parameters parameters, string title, string helpDescription, string helpOutput,
IList<string> helpSuppls)
{
InitializeComponent();
parameterPanel1.Init(parameters);
string text = "";
if (!string.IsNullOrEmpty(helpDescription)){
text += "\n\nDescription:\n " + helpDescription;
}
if (!string.IsNullOrEmpty(helpOutput)){
text += "\n\nOutput:\n " + helpOutput;
}
if (helpSuppls != null){
for (int i = 0; i < helpSuppls.Count; i++){
if (!string.IsNullOrEmpty(helpSuppls[i])){
text += "\n\nSuppl. table " + (i + 1) + ":\n " + helpSuppls[i];
}
}
}
helpTextBox.Text = text;
Text = title;
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
float value = (float) param.GetDoubleParam("Value").Value;
ReplaceMissingsByVal(value, mdata);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
SingleChoiceWithSubParams access = param.GetSingleChoiceWithSubParams("Matrix access");
bool rows = access.Value == 0;
int groupInd;
if (rows){
groupInd = access.GetSubParameters().GetSingleChoiceParam("Grouping").Value - 1;
} else{
groupInd = -1;
}
int what = param.GetSingleChoiceParam("Subtract what").Value;
if (groupInd < 0){
SubtractValues(rows, GetFunc(what), mdata, processInfo.NumThreads);
} else{
string[][] catRow = mdata.GetCategoryRowAt(groupInd);
foreach (string[] t in catRow){
if (t.Length > 1){
processInfo.ErrString = "The groups are overlapping.";
return;
}
}
SubtractGroups(mdata, catRow, GetFunc(what));
}
}
public void ProcessData(IMatrixData data, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
bool falseAreIndicated = param.GetSingleChoiceParam("Indicated are").Value == 0;
int catCol = param.GetSingleChoiceParam("In column").Value;
string word = param.GetStringParam("Indicator").Value;
int[] scoreColumns = param.GetMultiChoiceParam("Scores").Value;
if (scoreColumns.Length == 0){
processInfo.ErrString = "Please specify at least one column with scores.";
return;
}
bool largeIsGood = param.GetBoolParam("Large values are good").Value;
int[] showColumns = param.GetMultiChoiceParam("Display quantity").Value;
if (showColumns.Length == 0){
processInfo.ErrString = "Please select at least one quantity to display";
return;
}
bool[] indCol = GetIndicatorColumn(falseAreIndicated, catCol, word, data);
List<string> expColNames = new List<string>();
List<float[]> expCols = new List<float[]>();
foreach (int scoreColumn in scoreColumns){
double[] vals = scoreColumn < data.NumericColumnCount
? data.NumericColumns[scoreColumn]
: ArrayUtils.ToDoubles(data.GetExpressionColumn(scoreColumn - data.NumericColumnCount));
string name = scoreColumn < data.NumericColumnCount
? data.NumericColumnNames[scoreColumn] : data.ExpressionColumnNames[scoreColumn - data.NumericColumnCount];
int[] order = GetOrder(vals, largeIsGood);
CalcCurve(ArrayUtils.SubArray(indCol, order), showColumns, name, expCols, expColNames);
}
float[,] expData = ToMatrix(expCols);
data.SetData(data.Name, expColNames, expData, new List<string>(), new List<string[]>(), new List<string>(),
new List<string[][]>(), new List<string>(), new List<double[]>(), new List<string>(), new List<double[][]>());
}
public IAnalysisResult AnalyzeData(IMatrixData mdata, Parameters param, ProcessInfo processInfo)
{
return new SelectRowsManuallyResult(mdata);
}
public int GetMaxThreads(Parameters parameters)
{
return int.MaxValue;
}
private static bool GetReduceMatrix(Parameters parameters)
{
return parameters.GetSingleChoiceParam("Filter mode").Value == 0;
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
double width = param.GetDoubleParam("Width").Value;
double shift = param.GetDoubleParam("Down shift").Value;
bool separateColumns = param.GetSingleChoiceParam("Mode").Value == 0;
if (separateColumns){
ReplaceMissingsByGaussianByColumn(width, shift, mdata);
} else{
ReplaceMissingsByGaussianWholeMatrix(width, shift, mdata);
}
}
private static void ProcessDataCreate(IMatrixData mdata, Parameters param)
{
string name = param.GetStringParam("Row name").Value;
double[] groupCol = new double[mdata.ExpressionColumnCount];
for (int i = 0; i < mdata.ExpressionColumnCount; i++){
string ename = mdata.ExpressionColumnNames[i];
double value = param.GetDoubleParam(ename).Value;
groupCol[i] = value;
}
mdata.AddNumericRow(name, name, groupCol);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
int numQuantiles = param.GetIntParam("Number of quantiles").Value;
int[] colInds = param.GetMultiChoiceParam("Columns").Value;
foreach (int colInd in colInds){
float[] vals = mdata.GetExpressionColumn(colInd);
List<int> v = new List<int>();
for (int i = 0; i < vals.Length; i++){
if (!float.IsNaN(vals[i])){
v.Add(i);
}
}
int[] o = v.ToArray();
vals = ArrayUtils.SubArray(vals, o);
int[] q = ArrayUtils.Order(vals);
o = ArrayUtils.SubArray(o, q);
string[][] catCol = new string[mdata.RowCount][];
for (int i = 0; i < catCol.Length; i++){
catCol[i] = new[]{"missing"};
}
for (int i = 0; i < o.Length; i++){
int catVal = (i*numQuantiles)/o.Length + 1;
catCol[o[i]] = new[]{"Q" + catVal};
}
string name = mdata.ExpressionColumnNames[colInd] + "_q";
string desc = "The column " + mdata.ExpressionColumnNames[colInd] + " has been divided into " + numQuantiles +
" quantiles.";
mdata.AddCategoryColumn(name, desc, catCol);
}
}
public Parameters GetEditParameters(IMatrixData mdata)
{
Parameters[] subParams = new Parameters[mdata.NumericRowCount];
for (int i = 0; i < subParams.Length; i++){
subParams[i] = GetEditParameters(mdata, i);
}
List<Parameter> par = new List<Parameter>{
new SingleChoiceWithSubParams("Numerical row")
{Values = mdata.NumericRowNames, SubParams = subParams, Help = "Select the numerical row that should be edited."}
};
return new Parameters(par);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
SingleChoiceWithSubParams scwsp = param.GetSingleChoiceWithSubParams("Action");
Parameters spar = scwsp.GetSubParameters();
switch (scwsp.Value){
case 0:
ProcessDataCreate(mdata, spar);
break;
case 1:
ProcessDataEdit(mdata, spar);
break;
case 2:
ProcessDataRename(mdata, spar);
break;
case 3:
ProcessDataDelete(mdata, spar);
break;
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
int colIndex = param.GetSingleChoiceParam("Control column").Value;
if (colIndex < mdata.ExpressionColumnCount){
DivideByColumn(mdata, colIndex);
} else{
DivideByColumnNum(mdata, colIndex - mdata.ExpressionColumnCount);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] cols = param.GetMultiChoiceParam("Columns").Value;
int truncIndex = param.GetSingleChoiceParam("Use for truncation").Value;
TestTruncation truncation = truncIndex == 0
? TestTruncation.Pvalue : (truncIndex == 1 ? TestTruncation.BenjaminiHochberg : TestTruncation.PermutationBased);
double threshold = param.GetDoubleParam("Threshold value").Value;
int sideInd = param.GetSingleChoiceParam("Side").Value;
TestSide side;
switch (sideInd){
case 0:
side = TestSide.Both;
break;
case 1:
side = TestSide.Left;
break;
case 2:
side = TestSide.Right;
break;
default:
throw new Exception("Never get here.");
}
foreach (int col in cols){
float[] r = mdata.GetExpressionColumn(col);
double[] pvals = CalcSignificanceA(r, side);
string[][] fdr;
switch (truncation){
case TestTruncation.Pvalue:
fdr = PerseusPluginUtils.CalcPvalueSignificance(pvals, threshold);
break;
case TestTruncation.BenjaminiHochberg:
fdr = PerseusPluginUtils.CalcBenjaminiHochbergFdr(pvals, threshold);
break;
default:
throw new Exception("Never get here.");
}
mdata.AddNumericColumn(mdata.ExpressionColumnNames[col] + " Significance A", "", pvals);
mdata.AddCategoryColumn(mdata.ExpressionColumnNames[col] + " A significant", "", fdr);
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
if (!mdata.HasQuality){
processInfo.ErrString = "No quality data loaded.";
return;
}
double threshold = param.GetDoubleParam("Threshold").Value;
for (int i = 0; i < mdata.RowCount; i++){
for (int j = 0; j < mdata.ExpressionColumnCount; j++){
float value = mdata.QualityValues[i, j];
if (mdata.QualityBiggerIsBetter){
if (value < threshold){
mdata[i, j] = float.NaN;
}
} else{
if (value > threshold){
mdata[i, j] = float.NaN;
}
}
}
}
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
bool rows = param.GetSingleChoiceParam("Matrix access").Value == 0;
double min = param.GetDoubleParam("Minimum").Value;
double max = param.GetDoubleParam("Maximum").Value;
MapToInterval1(rows, mdata, min, max);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] cols = param.GetMultiChoiceParam("Columns").Value;
HashSet<int> w = ArrayUtils.ToHashSet(param.GetMultiChoiceParam("Calculate").Value);
bool[] include = new bool[SummaryStatisticsRows.procs.Length];
double[][] rowws = new double[SummaryStatisticsRows.procs.Length][];
for (int i = 0; i < include.Length; i++){
include[i] = w.Contains(i);
if (include[i]){
rowws[i] = new double[cols.Length];
}
}
for (int i = 0; i < cols.Length; i++){
double[] vals = GetColumn(cols[i], mdata);
for (int j = 0; j < include.Length; j++){
if (include[j]){
rowws[j][i] = SummaryStatisticsRows.procs[j].Item2(vals);
}
}
}
List<double[]> ex = new List<double[]>();
List<string> names = new List<string>();
for (int i = 0; i < include.Length; i++){
if (include[i]){
ex.Add(rowws[i]);
names.Add(SummaryStatisticsRows.procs[i].Item1);
}
}
float[,] exVals = GetExVals(ex);
string[] colNames = GetColNames(mdata, cols);
mdata.SetData("Summary", new List<string>(names.ToArray()), exVals, new List<string>(new[]{"Columns"}),
new List<string[]>(new[]{colNames}), mdata.CategoryRowNames,
TransformCategories(mdata, cols, mdata.ExpressionColumnCount), mdata.NumericRowNames,
TransformNumeric(mdata.NumericRows, cols, mdata.ExpressionColumnCount), new List<string>(), new List<double[][]>());
}
public void ProcessData(IMatrixData data, Parameters param, ref IMatrixData[] supplTables,
ref IDocumentData[] documents, ProcessInfo processInfo)
{
int[] exColInds = GetValidExCols(data);
int[] numColInds = GetValidNumCols(data);
int[] multiNumColInds = GetValidMultiNumCols(data);
int[] catColInds = GetValidCatCols(data);
int[] textColInds = GetValidTextCols(data);
if (exColInds.Length < data.ExpressionColumnCount){
data.ExtractExpressionColumns(exColInds);
}
if (numColInds.Length < data.NumericColumnCount){
data.NumericColumns = ArrayUtils.SubList(data.NumericColumns, numColInds);
data.NumericColumnNames = ArrayUtils.SubList(data.NumericColumnNames, numColInds);
data.NumericColumnDescriptions = ArrayUtils.SubList(data.NumericColumnDescriptions, numColInds);
}
if (multiNumColInds.Length < data.MultiNumericColumnCount){
data.MultiNumericColumns = ArrayUtils.SubList(data.MultiNumericColumns, multiNumColInds);
data.MultiNumericColumnNames = ArrayUtils.SubList(data.MultiNumericColumnNames, multiNumColInds);
data.MultiNumericColumnDescriptions = ArrayUtils.SubList(data.MultiNumericColumnDescriptions, multiNumColInds);
}
if (catColInds.Length < data.CategoryColumnCount){
data.CategoryColumns = PerseusPluginUtils.GetCategoryColumns(data, catColInds);
data.CategoryColumnNames = ArrayUtils.SubList(data.CategoryColumnNames, catColInds);
data.CategoryColumnDescriptions = ArrayUtils.SubList(data.CategoryColumnDescriptions, catColInds);
}
if (textColInds.Length < data.StringColumnCount){
data.StringColumns = ArrayUtils.SubList(data.StringColumns, textColInds);
data.StringColumnNames = ArrayUtils.SubList(data.StringColumnNames, textColInds);
data.StringColumnDescriptions = ArrayUtils.SubList(data.StringColumnDescriptions, textColInds);
}
}
private static void ProcessDataRename(IMatrixData mdata, Parameters param)
{
int groupColInd = param.GetSingleChoiceParam("Numerical row").Value;
string newName = param.GetStringParam("New name").Value;
string newDescription = param.GetStringParam("New description").Value;
mdata.NumericRowNames[groupColInd] = newName;
mdata.NumericRowDescriptions[groupColInd] = newDescription;
}
public IMatrixData CombineData(IMatrixData matrixData1, IMatrixData matrixData2, Parameters parameters,
ProcessInfo processInfo)
{
bool indicator = parameters.GetBoolParam("Indicator").Value;
int otherCol = parameters.GetSingleChoiceParam("Matching column 2").Value;
Average avExpression = GetAveraging(parameters.GetSingleChoiceParam("Combine expression values").Value);
Average avNumerical = GetAveraging(parameters.GetSingleChoiceParam("Combine numerical values").Value);
string[] q = matrixData2.StringColumns[otherCol];
string[][] w = new string[q.Length][];
for (int i = 0; i < q.Length; i++){
string r = q[i].Trim();
w[i] = r.Length == 0 ? new string[0] : r.Split(';');
w[i] = ArrayUtils.UniqueValues(w[i]);
}
Dictionary<string, List<int>> id2Cols = new Dictionary<string, List<int>>();
for (int i = 0; i < w.Length; i++){
foreach (string s in w[i]){
if (!id2Cols.ContainsKey(s)){
id2Cols.Add(s, new List<int>());
}
id2Cols[s].Add(i);
}
}
int pgCol = parameters.GetSingleChoiceParam("Matching column 1").Value;
string[] d = matrixData1.StringColumns[pgCol];
string[][] x = new string[d.Length][];
for (int i = 0; i < d.Length; i++){
string r = d[i].Trim();
x[i] = r.Length == 0 ? new string[0] : r.Split(';');
x[i] = ArrayUtils.UniqueValues(x[i]);
}
int[][] indexMap = new int[x.Length][];
string[][] indicatorCol = new string[x.Length][];
for (int i = 0; i < indexMap.Length; i++){
List<int> qwer = new List<int>();
foreach (string s in x[i]){
if (id2Cols.ContainsKey(s)){
List<int> en = id2Cols[s];
qwer.AddRange(en);
}
}
indexMap[i] = qwer.ToArray();
indexMap[i] = ArrayUtils.UniqueValues(indexMap[i]);
indicatorCol[i] = indexMap[i].Length > 0 ? new[]{"+"} : new string[0];
}
IMatrixData result = matrixData1.Copy();
SetAnnotationRows(result, matrixData1, matrixData2);
if (indicator){
result.AddCategoryColumn(matrixData2.Name, "", indicatorCol);
}
{
int[] exCols = parameters.GetMultiChoiceParam("Expression columns").Value;
float[,] newExColumns = new float[matrixData1.RowCount, exCols.Length];
float[,] newQuality = new float[matrixData1.RowCount, exCols.Length];
bool[,] newIsImputed = new bool[matrixData1.RowCount, exCols.Length];
string[] newExColNames = new string[exCols.Length];
float[,] oldEx = matrixData2.ExpressionValues;
float[,] oldQual = matrixData2.QualityValues;
bool[,] oldImp = matrixData2.IsImputed;
for (int i = 0; i < exCols.Length; i++) {
newExColNames[i] = matrixData2.ExpressionColumnNames[exCols[i]];
for (int j = 0; j < matrixData1.RowCount; j++){
int[] inds = indexMap[j];
List<double> values = new List<double>();
List<double> qual = new List<double>();
List<bool> imp = new List<bool>();
foreach (int ind in inds) {
double v = oldEx[ind, exCols[i]];
if (!double.IsNaN(v) && !double.IsInfinity(v)){
values.Add(v);
double qx = oldQual[ind, exCols[i]];
if (!double.IsNaN(qx) && !double.IsInfinity(qx)){
qual.Add(qx);
}
bool isi = oldImp[ind, exCols[i]];
imp.Add(isi);
}
}
newExColumns[j, i] = values.Count == 0 ? float.NaN : (float)avExpression(values.ToArray());
newQuality[j, i] = qual.Count == 0 ? float.NaN : (float)avExpression(qual.ToArray());
newIsImputed[j, i] = imp.Count != 0 && AvImp(imp.ToArray());
}
}
MakeNewNames(newExColNames, result.ExpressionColumnNames);
AddExpressionColumns(result, newExColNames, newExColumns, newQuality, newIsImputed);
}
{
int[] numCols = parameters.GetMultiChoiceParam("Numerical columns").Value;
double[][] newNumericalColumns = new double[numCols.Length][];
string[] newNumColNames = new string[numCols.Length];
for (int i = 0; i < numCols.Length; i++){
double[] oldCol = matrixData2.NumericColumns[numCols[i]];
newNumColNames[i] = matrixData2.NumericColumnNames[numCols[i]];
newNumericalColumns[i] = new double[matrixData1.RowCount];
for (int j = 0; j < matrixData1.RowCount; j++){
int[] inds = indexMap[j];
List<double> values = new List<double>();
foreach (int ind in inds){
double v = oldCol[ind];
if (!double.IsNaN(v)){
values.Add(v);
}
}
newNumericalColumns[i][j] = values.Count == 0 ? double.NaN : avNumerical(values.ToArray());
}
}
for (int i = 0; i < numCols.Length; i++){
result.AddNumericColumn(newNumColNames[i], "", newNumericalColumns[i]);
}
}
{
int[] catCols = parameters.GetMultiChoiceParam("Categorical columns").Value;
string[][][] newCatColumns = new string[catCols.Length][][];
string[] newCatColNames = new string[catCols.Length];
for (int i = 0; i < catCols.Length; i++){
string[][] oldCol = matrixData2.CategoryColumns[catCols[i]];
newCatColNames[i] = matrixData2.CategoryColumnNames[catCols[i]];
newCatColumns[i] = new string[matrixData1.RowCount][];
for (int j = 0; j < matrixData1.RowCount; j++){
int[] inds = indexMap[j];
List<string[]> values = new List<string[]>();
foreach (int ind in inds){
string[] v = oldCol[ind];
if (v.Length > 0){
values.Add(v);
}
}
newCatColumns[i][j] = values.Count == 0
? new string[0] : ArrayUtils.UniqueValues(ArrayUtils.Concat(values.ToArray()));
}
}
for (int i = 0; i < catCols.Length; i++){
result.AddCategoryColumn(newCatColNames[i], "", newCatColumns[i]);
}
}
{
int[] stringCols = parameters.GetMultiChoiceParam("String columns").Value;
string[][] newStringColumns = new string[stringCols.Length][];
string[] newStringColNames = new string[stringCols.Length];
for (int i = 0; i < stringCols.Length; i++){
string[] oldCol = matrixData2.StringColumns[stringCols[i]];
newStringColNames[i] = matrixData2.StringColumnNames[stringCols[i]];
newStringColumns[i] = new string[matrixData1.RowCount];
for (int j = 0; j < matrixData1.RowCount; j++){
int[] inds = indexMap[j];
List<string> values = new List<string>();
foreach (int ind in inds){
string v = oldCol[ind];
if (v.Length > 0){
values.Add(v);
}
}
newStringColumns[i][j] = values.Count == 0 ? "" : StringUtils.Concat(";", values.ToArray());
}
}
for (int i = 0; i < stringCols.Length; i++){
result.AddStringColumn(newStringColNames[i], "", newStringColumns[i]);
}
}
result.Origin = "Combination";
return result;
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
SingleChoiceParam access = param.GetSingleChoiceParam("Matrix access");
bool rows = access.Value == 0;
UnitVectors(rows, mdata);
}
private static void ProcessDataDelete(IMatrixData mdata, Parameters param)
{
int groupColInd = param.GetSingleChoiceParam("Numerical row").Value;
mdata.NumericRows.RemoveAt(groupColInd);
mdata.NumericRowNames.RemoveAt(groupColInd);
mdata.NumericRowDescriptions.RemoveAt(groupColInd);
}
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo)
{
}
public int GetMaxThreads(Parameters parameters)
{
return 1;
}
private static void ProcessDataEdit(IMatrixData mdata, Parameters param)
{
SingleChoiceWithSubParams s = param.GetSingleChoiceWithSubParams("Numerical row");
int groupColInd = s.Value;
Parameters sp = s.GetSubParameters();
for (int i = 0; i < mdata.ExpressionColumnCount; i++){
string t = mdata.ExpressionColumnNames[i];
double x = sp.GetDoubleParam(t).Value;
mdata.NumericRows[groupColInd][i] = x;
}
}
