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 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; } }
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; } }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents, ProcessInfo processInfo) { int[] outputColumns = param.GetMultiChoiceParam("Output").Value; int proteinIdColumnInd = param.GetSingleChoiceParam("Protein IDs").Value; string[] proteinIds = mdata.StringColumns[proteinIdColumnInd]; int[] intensityCols = param.GetMultiChoiceParam("Intensities").Value; if (intensityCols.Length == 0){ processInfo.ErrString = "Please select at least one column containing protein intensities."; return; } // variable to hold all intensity values List<double[]> columns = new List<double[]>(); string[] sampleNames = new string[intensityCols.Length]; for (int col = 0; col < intensityCols.Length; col++){ double[] values; if (intensityCols[col] < mdata.ExpressionColumnCount){ values = ArrayUtils.ToDoubles(mdata.GetExpressionColumn(intensityCols[col])); sampleNames[col] = mdata.ExpressionColumnNames[intensityCols[col]]; } else{ values = mdata.NumericColumns[intensityCols[col] - mdata.ExpressionColumnCount]; sampleNames[col] = mdata.NumericColumnNames[intensityCols[col] - mdata.ExpressionColumnCount]; } sampleNames[col] = new Regex(@"^(?:(?:LFQ )?[Ii]ntensity )?(.*)$").Match(sampleNames[col]).Groups[1].Value; columns.Add(values); } // average over columns if this option is selected if (param.GetSingleChoiceWithSubParams("Averaging mode").Value == 3){ double[] column = new double[mdata.RowCount]; for (int row = 0; row < mdata.RowCount; row++){ double[] values = new double[intensityCols.Length]; for (int col = 0; col < intensityCols.Length; col++){ values[col] = columns[col][row]; } column[row] = ArrayUtils.Median(ExtractValidValues(values, false)); } // delete the original list of columns columns = new List<double[]>{column}; sampleNames = new[]{""}; } // revert logarithm if necessary if (param.GetBoolWithSubParams("Logarithmized").Value){ double[] logBases = new[]{2, Math.E, 10}; double logBase = logBases[param.GetBoolWithSubParams("Logarithmized").GetSubParameters().GetSingleChoiceParam("log base").Value]; foreach (double[] t in columns){ for (int row = 0; row < mdata.RowCount; row++){ if (t[row] == 0){ processInfo.ErrString = "Are the columns really logarithmized?\nThey contain zeroes!"; } t[row] = Math.Pow(logBase, t[row]); } } } double[] mw = mdata.NumericColumns[param.GetSingleChoiceParam("Molecular masses").Value]; // detect whether the molecular masses are given in Da or kDa if (ArrayUtils.Median(mw) < 250) // likely kDa { for (int i = 0; i < mw.Length; i++){ mw[i] *= 1000; } } double[] detectabilityNormFactor = mw; if (param.GetBoolWithSubParams("Detectability correction").Value){ detectabilityNormFactor = mdata.NumericColumns[ param.GetBoolWithSubParams("Detectability correction") .GetSubParameters() .GetSingleChoiceParam("Correction factor") .Value]; } // the normalization factor needs to be nonzero for all proteins // check and replace with 1 for all relevant cases for (int row = 0; row < mdata.RowCount; row++){ if (detectabilityNormFactor[row] == 0 || detectabilityNormFactor[row] == double.NaN){ detectabilityNormFactor[row] = 1; } } // detect the organism Organism organism = DetectOrganism(proteinIds); // c value the amount of DNA per cell, see: http://en.wikipedia.org/wiki/C-value double cValue = (organism.genomeSize*basePairWeight)/avogadro; // find the histones int[] histoneRows = FindHistones(proteinIds, organism); // write a categorical column indicating the histones string[][] histoneCol = new string[mdata.RowCount][]; for (int row = 0; row < mdata.RowCount; row++){ histoneCol[row] = (ArrayUtils.Contains(histoneRows, row)) ? new[]{"+"} : new[]{""}; } mdata.AddCategoryColumn("Histones", "", histoneCol); // initialize the variables for the annotation rows double[] totalProteinRow = new double[mdata.ExpressionColumnCount]; double[] totalMoleculesRow = new double[mdata.ExpressionColumnCount]; string[][] organismRow = new string[mdata.ExpressionColumnCount][]; double[] histoneMassRow = new double[mdata.ExpressionColumnCount]; double[] ploidyRow = new double[mdata.ExpressionColumnCount]; double[] cellVolumeRow = new double[mdata.ExpressionColumnCount]; double[] normalizationFactors = new double[columns.Count]; // calculate normalization factors for each column for (int col = 0; col < columns.Count; col++){ string sampleName = sampleNames[col]; double[] column = columns[col]; // normalization factor to go from intensities to copies, // needs to be determined either using the total protein or the histone scaling approach double factor; switch (param.GetSingleChoiceWithSubParams("Scaling mode").Value){ case 0: // total protein amount double mwWeightedNormalizedSummedIntensities = 0; for (int row = 0; row < mdata.RowCount; row++){ if (!double.IsNaN(column[row]) && !double.IsNaN(mw[row])){ mwWeightedNormalizedSummedIntensities += (column[row]/detectabilityNormFactor[row])*mw[row]; } } factor = (param.GetSingleChoiceWithSubParams("Scaling mode") .GetSubParameters() .GetDoubleParam("Protein amount per cell [pg]") .Value*1e-12*avogadro)/mwWeightedNormalizedSummedIntensities; break; case 1: // histone mode double mwWeightedNormalizedSummedHistoneIntensities = 0; foreach (int row in histoneRows){ if (!double.IsNaN(column[row]) && !double.IsNaN(mw[row])){ mwWeightedNormalizedSummedHistoneIntensities += (column[row]/detectabilityNormFactor[row])*mw[row]; } } double ploidy = param.GetSingleChoiceWithSubParams("Scaling mode").GetSubParameters().GetDoubleParam("Ploidy").Value; factor = (cValue*ploidy*avogadro)/mwWeightedNormalizedSummedHistoneIntensities; break; default: factor = 1; break; } normalizationFactors[col] = factor; } // check averaging mode if (param.GetSingleChoiceWithSubParams("Averaging mode").Value == 1) // same factor for all { double factor = ArrayUtils.Mean(normalizationFactors); for (int i = 0; i < normalizationFactors.Length; i++){ normalizationFactors[i] = factor; } } if (param.GetSingleChoiceWithSubParams("Averaging mode").Value == 2) // same factor in each group { if ( param.GetSingleChoiceWithSubParams("Averaging mode").GetSubParameters().GetSingleChoiceParam("Grouping").Value == -1){ processInfo.ErrString = "No grouping selected."; return; } string[][] groupNames = mdata.GetCategoryRowAt( param.GetSingleChoiceWithSubParams("Averaging mode").GetSubParameters().GetSingleChoiceParam("Grouping").Value); string[] uniqueGroupNames = Unique(groupNames); int[] grouping = new int[columns.Count]; for (int i = 0; i < columns.Count; i++){ if (intensityCols[i] >= mdata.ExpressionColumnCount){ // Numeric annotation columns cannot be grouped grouping[i] = i; continue; } if (ArrayUtils.Contains(uniqueGroupNames, groupNames[i][0])){ grouping[i] = ArrayUtils.IndexOf(uniqueGroupNames, groupNames[i][0]); continue; } grouping[i] = i; } Dictionary<int, List<double>> factors = new Dictionary<int, List<double>>(); for (int i = 0; i < columns.Count; i++){ if (factors.ContainsKey(grouping[i])){ factors[grouping[i]].Add(normalizationFactors[i]); } else{ factors.Add(grouping[i], new List<double>{normalizationFactors[i]}); } } double[] averagedNormalizationFactors = new double[columns.Count]; for (int i = 0; i < columns.Count; i++){ List<double> factor; factors.TryGetValue(grouping[i], out factor); averagedNormalizationFactors[i] = ArrayUtils.Mean(factor); } normalizationFactors = averagedNormalizationFactors; } // loop over all selected columns and calculate copy numbers for (int col = 0; col < columns.Count; col++){ string sampleName = sampleNames[col]; double[] column = columns[col]; double factor = normalizationFactors[col]; double[] copyNumbers = new double[mdata.RowCount]; double[] concentrations = new double[mdata.RowCount]; // femtoliters double[] massFraction = new double[mdata.RowCount]; double[] moleFraction = new double[mdata.RowCount]; double totalProtein = 0; // picograms double histoneMass = 0; // picograms double totalMolecules = 0; for (int row = 0; row < mdata.RowCount; row++){ if (!double.IsNaN(column[row]) && !double.IsNaN(mw[row])){ copyNumbers[row] = (column[row]/detectabilityNormFactor[row])*factor; totalMolecules += copyNumbers[row]; totalProtein += (copyNumbers[row]*mw[row]*1e12)/avogadro; // picograms if (ArrayUtils.Contains(histoneRows, row)){ histoneMass += (copyNumbers[row]*mw[row]*1e12)/avogadro; // picograms } } } double totalVolume = (totalProtein/(param.GetDoubleParam("Total cellular protein concentration [g/l]").Value))*1000; // femtoliters for (int row = 0; row < mdata.RowCount; row++){ if (!double.IsNaN(column[row]) && !double.IsNaN(mw[row])){ concentrations[row] = ((copyNumbers[row]/(totalVolume*1e-15))/avogadro)*1e9; // nanomolar massFraction[row] = (((copyNumbers[row]*mw[row]*1e12)/avogadro)/totalProtein)*1e6; // ppm moleFraction[row] = (copyNumbers[row]/totalMolecules)*1e6; // ppm } } string suffix = (sampleName == "") ? "" : " " + sampleName; if (ArrayUtils.Contains(outputColumns, 0)){ mdata.AddNumericColumn("Copy number" + suffix, "", copyNumbers); } if (ArrayUtils.Contains(outputColumns, 1)){ mdata.AddNumericColumn("Concentration [nM]" + suffix, "", concentrations); } if (ArrayUtils.Contains(outputColumns, 2)){ mdata.AddNumericColumn("Abundance (mass/total mass) [*10^-6]" + suffix, "", massFraction); } if (ArrayUtils.Contains(outputColumns, 3)){ mdata.AddNumericColumn("Abundance (molecules/total molecules) [*10^-6]" + suffix, "", moleFraction); } double[] rank = ArrayUtils.Rank(copyNumbers); double[] relativeRank = new double[mdata.RowCount]; double validRanks = mdata.RowCount; for (int row = 0; row < mdata.RowCount; row++){ // remove rank for protein with no copy number information if (double.IsNaN((copyNumbers[row])) || copyNumbers[row] == 0){ rank[row] = double.NaN; validRanks--; // do not consider as valid } // invert ranking, so that rank 0 is the most abundant protein rank[row] = mdata.RowCount - rank[row]; } for (int row = 0; row < mdata.RowCount; row++){ relativeRank[row] = rank[row]/validRanks; } if (ArrayUtils.Contains(outputColumns, 4)){ mdata.AddNumericColumn("Copy number rank" + suffix, "", rank); } if (ArrayUtils.Contains(outputColumns, 5)){ mdata.AddNumericColumn("Relative copy number rank" + suffix, "", relativeRank); } if (intensityCols[col] < mdata.ExpressionColumnCount && param.GetSingleChoiceWithSubParams("Averaging mode").Value != 3){ totalProteinRow[intensityCols[col]] = Math.Round(totalProtein, 2); totalMoleculesRow[intensityCols[col]] = Math.Round(totalMolecules, 0); organismRow[intensityCols[col]] = new string[]{organism.name}; histoneMassRow[intensityCols[col]] = Math.Round(histoneMass, 4); ploidyRow[intensityCols[col]] = Math.Round((histoneMass*1e-12)/cValue, 2); cellVolumeRow[intensityCols[col]] = Math.Round(totalVolume, 2); // femtoliters } } if (param.GetSingleChoiceWithSubParams("Averaging mode").Value != 3 && ArrayUtils.Contains(outputColumns, 6)){ mdata.AddNumericRow("Total protein [pg/cell]", "", totalProteinRow); mdata.AddNumericRow("Total molecules per cell", "", totalMoleculesRow); mdata.AddCategoryRow("Organism", "", organismRow); mdata.AddNumericRow("Histone mass [pg/cell]", "", histoneMassRow); mdata.AddNumericRow("Ploidy", "", ploidyRow); mdata.AddNumericRow("Cell volume [fl]", "", cellVolumeRow); } }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents, ProcessInfo processInfo) { SingleChoiceWithSubParams xp = param.GetSingleChoiceWithSubParams("Expression column selection"); bool groups = xp.Value == 2; string[] groupNames = null; int[][] colIndsGroups = null; if (groups){ int groupRowInd = xp.GetSubParameters().GetSingleChoiceParam("Group").Value; string[][] groupCol = mdata.GetCategoryRowAt(groupRowInd); groupNames = ArrayUtils.UniqueValuesPreserveOrder(groupCol); colIndsGroups = PerseusPluginUtils.GetExpressionColIndices(groupCol, groupNames); } int[] useCols = xp.Value == 1 ? xp.GetSubParameters().GetMultiChoiceParam("Columns").Value : ArrayUtils.ConsecutiveInts(mdata.ExpressionColumnCount); HashSet<int> w = ArrayUtils.ToHashSet(param.GetMultiChoiceParam("Calculate").Value); bool[] include = new bool[procs.Length]; double[][] columns = new double[procs.Length][]; double[][][] columnsG = null; if (groups){ columnsG = new double[procs.Length][][]; for (int i = 0; i < columnsG.Length; i++){ columnsG[i] = new double[groupNames.Length][]; } } for (int i = 0; i < include.Length; i++){ include[i] = w.Contains(i); if (include[i]){ columns[i] = new double[mdata.RowCount]; if (groups){ for (int j = 0; j < groupNames.Length; j++){ columnsG[i][j] = new double[mdata.RowCount]; } } } } for (int i = 0; i < mdata.RowCount; i++){ List<double> v = new List<double>(); foreach (int j in useCols){ double x = mdata[i, j]; if (!double.IsNaN(x) && !double.IsInfinity(x)){ v.Add(x); } } for (int j = 0; j < include.Length; j++){ if (include[j]){ columns[j][i] = procs[j].Item2(v); } } if (groups){ List<double>[] vg = new List<double>[groupNames.Length]; for (int j = 0; j < colIndsGroups.Length; j++){ vg[j] = new List<double>(); for (int k = 0; k < colIndsGroups[j].Length; k++){ double x = mdata[i, colIndsGroups[j][k]]; if (!double.IsNaN(x) && !double.IsInfinity(x)){ vg[j].Add(x); } } } for (int j = 0; j < include.Length; j++){ if (include[j]){ for (int k = 0; k < groupNames.Length; k++){ columnsG[j][k][i] = procs[j].Item2(vg[k]); } } } } } for (int i = 0; i < include.Length; i++){ if (include[i]){ mdata.AddNumericColumn(procs[i].Item1, procs[i].Item3, columns[i]); if (groups){ for (int k = 0; k < groupNames.Length; k++){ mdata.AddNumericColumn(procs[i].Item1 + " " + groupNames[k], procs[i].Item3, columnsG[i][k]); } } } } }
private static void ProcessDataCreateFromGoupNames(IMatrixData mdata, Parameters param, ProcessInfo processInfo) { SingleChoiceWithSubParams scwsp = param.GetSingleChoiceWithSubParams("Pattern"); Parameters spar = scwsp.GetSubParameters(); string regexString = ""; string replacement = ""; switch (scwsp.Value) { case 0: case 1: case 2: regexString = GetSelectableRegexes()[scwsp.Value][1]; break; case 3: regexString = spar.GetStringParam("Regex").Value; break; case 4: regexString = spar.GetStringParam("Regex").Value; replacement = spar.GetStringParam("Replace with").Value; break; default: break; } Regex regex; try{ regex = new Regex(regexString); } catch (ArgumentException){ processInfo.ErrString = "The regular expression you provided has invalid syntax."; return; } List<string[]> groupNames = new List<string[]>(); foreach (string sampleName in mdata.ExpressionColumnNames) { string groupName = scwsp.Value < 4 ? regex.Match(sampleName).Groups[1].Value : regex.Replace(sampleName, replacement); if (string.IsNullOrEmpty(groupName)) groupName = sampleName; groupNames.Add(new[] { groupName }); } mdata.AddCategoryRow("Grouping", "", groupNames.ToArray()); }
private static void ProcessDataEdit(IMatrixData mdata, Parameters param) { SingleChoiceWithSubParams s = param.GetSingleChoiceWithSubParams("Category row"); int groupColInd = s.Value; Parameters sp = s.GetSubParameters(); string[][] newRow = new string[mdata.ExpressionColumnCount][]; for (int i = 0; i < mdata.ExpressionColumnCount; i++){ string t = mdata.ExpressionColumnNames[i]; string x = sp.GetStringParam(t).Value; newRow[i] = x.Length > 0 ? x.Split(';') : new string[0]; } mdata.SetCategoryRowAt(newRow, groupColInd); }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents, ProcessInfo processInfo) { const bool rows = false; int minValids = param.GetIntParam("Min. number of values").Value; SingleChoiceWithSubParams modeParam = param.GetSingleChoiceWithSubParams("Mode"); int modeInd = modeParam.Value; if (modeInd != 0 && mdata.CategoryRowNames.Count == 0){ processInfo.ErrString = "No grouping is defined."; return; } if (modeInd != 0){ processInfo.ErrString = "Group-wise filtering can only be appled to rows."; return; } SingleChoiceWithSubParams x = param.GetSingleChoiceWithSubParams("Values should be"); Parameters subParams = x.GetSubParameters(); int shouldBeIndex = x.Value; FilteringMode filterMode; double threshold = double.NaN; double threshold2 = double.NaN; switch (shouldBeIndex){ case 0: filterMode = FilteringMode.Valid; break; case 1: filterMode = FilteringMode.GreaterThan; threshold = subParams.GetDoubleParam("Minimum").Value; break; case 2: filterMode = FilteringMode.GreaterEqualThan; threshold = subParams.GetDoubleParam("Minimum").Value; break; case 3: filterMode = FilteringMode.LessThan; threshold = subParams.GetDoubleParam("Maximum").Value; break; case 4: filterMode = FilteringMode.LessEqualThan; threshold = subParams.GetDoubleParam("Maximum").Value; break; case 5: filterMode = FilteringMode.Between; threshold = subParams.GetDoubleParam("Minimum").Value; threshold2 = subParams.GetDoubleParam("Maximum").Value; break; case 6: filterMode = FilteringMode.Outside; threshold = subParams.GetDoubleParam("Minimum").Value; threshold2 = subParams.GetDoubleParam("Maximum").Value; break; default: throw new Exception("Should not happen."); } if (modeInd != 0){ int gind = modeParam.GetSubParameters().GetSingleChoiceParam("Grouping").Value; string[][] groupCol = mdata.GetCategoryRowAt(gind); NonzeroFilterGroup(minValids, mdata, param, modeInd == 2, threshold, threshold2, filterMode, groupCol); } else{ NonzeroFilter1(rows, minValids, mdata, param, threshold, threshold2, filterMode); } }
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: ProcessDataCreateFromGoupNames(mdata, spar, processInfo); break; case 2: ProcessDataEdit(mdata, spar); break; case 3: ProcessDataRename(mdata, spar); break; case 4: ProcessDataDelete(mdata, spar); break; case 5: ProcessDataWriteTemplateFile(mdata, spar); break; case 6: string err = ProcessDataReadFromFile(mdata, spar); if (err != null){ processInfo.ErrString = err; } break; } }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents, ProcessInfo processInfo) { SingleChoiceWithSubParams p = param.GetSingleChoiceWithSubParams("Row"); int colInd = p.Value; if (colInd < 0) { processInfo.ErrString = "No categorical rows available."; return; } MultiChoiceParam mcp = p.GetSubParameters().GetMultiChoiceParam("Values"); int[] inds = mcp.Value; if (inds.Length < 1) { processInfo.ErrString = "Please select at least two terms for merging."; return; } string newTerm = param.GetStringParam("New term").Value; if (newTerm.Length == 0){ processInfo.ErrString = "Please specify a new term."; return; } string[] values = new string[inds.Length]; for (int i = 0; i < values.Length; i++) { values[i] = mdata.GetCategoryRowValuesAt(colInd)[inds[i]]; } HashSet<string> value = new HashSet<string>(values); string[][] cats = mdata.GetCategoryRowAt(colInd); string[][] newCat = new string[cats.Length][]; for (int i = 0; i < cats.Length; i++){ string[] w = cats[i]; bool changed = false; for (int j = 0; j < w.Length; j++){ if (value.Contains(w[j])){ w[j] = newTerm; changed = true; } } if (changed){ Array.Sort(w); } newCat[i] = w; } mdata.SetCategoryRowAt(newCat, colInd); }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo) { bool rows = param.GetSingleChoiceParam("Matrix access").Value == 0; bool atLeast = param.GetSingleChoiceParam("Side").Value == 0; int numValids = param.GetIntParam("Number of valid values").Value; SingleChoiceWithSubParams modeParam = param.GetSingleChoiceWithSubParams("Mode"); int modeInd = modeParam.Value; if (modeInd != 0 && mdata.CategoryRowNames.Count == 0){ processInfo.ErrString = "No grouping is defined."; return; } if (modeInd != 0 && !rows){ processInfo.ErrString = "Group-wise filtering can only be appled to rows."; return; } if (modeInd != 0){ int gind = modeParam.GetSubParameters().GetSingleChoiceParam("Grouping").Value; string[][] groupCol = mdata.CategoryRows[gind]; ValidValueFilterGroup(numValids, mdata, param, modeInd == 2, groupCol, atLeast); } else{ ValidValueFilter1(rows, numValids, mdata, param, atLeast); } }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ProcessInfo processInfo) { SingleChoiceWithSubParams sp = param.GetSingleChoiceWithSubParams("Source type"); Parameters subParams = sp.GetSubParameters(); int[] colInds = subParams.GetMultiChoiceParam("Columns").Value; int which = subParams.GetSingleChoiceParam("Target type").Value; switch (sp.Value){ case 0: ExpressionToNumeric(colInds, mdata); break; case 1: if (which == 0){ NumericToCategorical(colInds, mdata); } else{ NumericToExpression(colInds, mdata); } break; case 2: if (which == 0){ CategoricalToNumeric(colInds, mdata); } else{ CategoricalToString(colInds, mdata); } break; case 3: StringToCategorical(colInds, mdata); break; default: throw new Exception("Never get here"); } }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, 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; } if (groupInd < 0){ Zscore(rows, mdata); } else{ string[][] catRow = mdata.CategoryRows[groupInd]; foreach (string[] t in catRow){ if (t.Length > 1){ processInfo.ErrString = "The groups are overlapping."; return; } } ZscoreGroups(mdata, catRow); } }
public void ProcessData(IMatrixData mdata, Parameters param, ref IMatrixData[] supplTables, ref IDocumentData[] documents, ProcessInfo processInfo) { SingleChoiceWithSubParams p = param.GetSingleChoiceWithSubParams("Row"); int colInd = p.Value; if (colInd < 0){ processInfo.ErrString = "No categorical rows available."; return; } MultiChoiceParam mcp = p.GetSubParameters().GetMultiChoiceParam("Values"); int[] inds = mcp.Value; if (inds.Length == 0){ processInfo.ErrString = "Please select at least one term for filtering."; return; } string[] values = new string[inds.Length]; for (int i = 0; i < values.Length; i++){ values[i] = mdata.GetCategoryRowValuesAt(colInd)[inds[i]]; } HashSet<string> value = new HashSet<string>(values); bool remove = param.GetSingleChoiceParam("Mode").Value == 0; string[][] cats = mdata.GetCategoryRowAt(colInd); List<int> valids = new List<int>(); for (int i = 0; i < cats.Length; i++){ bool valid = true; foreach (string w in cats[i]){ if (value.Contains(w)){ valid = false; break; } } if ((valid && remove) || (!valid && !remove)){ valids.Add(i); } } PerseusPluginUtils.FilterColumns(mdata, param, valids.ToArray()); }