29: 	std::vector< std::vector<Object> > array;

5: class Basic2DMatrix

8: 	Basic2DMatrix( int rows, int cols ) : array( rows )

14: 	Basic2DMatrix( const Basic2DMatrix & rhs ) : array( rhs.array ) { }

2: #define BASIC2DMATRIX_H

11: 			array[ i ].resize( cols );

17: 	{ return array[ row ]; }

20: 	{ return array[ row ]; }

23: 	{ return array.size( ); }

26: 	{ return numrows( ) ? array[ 0 ].size( ) : 0; }

1: #ifndef BASIC2DMATRIX_H

32: #endif  // BASIC2DMATRIX

161:     array <- annotation(rgSet)[["array"]]

197:     array <- extractedData$array

90:     model.matrix <- .buildControlMatrix450k(extractedData)

313:     model.matrix <- cbind(

407: .normalizeMatrix <- function(intMatrix, newQuantiles) {

410:     normMatrix <- sapply(1:ncol(intMatrix), function(i) {

189: .buildControlMatrix450k <- function(extractedData) {

385:         controlMatrix1 <- controlMatrix[sex == levels[1], ]

392:         controlMatrix2 <- controlMatrix[sex == levels[2], ]

2: ## Functional normalization of the 450k array

7: ## Return a normalized beta matrix

77:      normalizeQuantiles <- function(matrix, indices, sex = NULL) {

78:          matrix <- matrix[indices,,drop=FALSE]

79:          ## uses probs, model.matrix, nPCS, through scoping)

80:          oldQuantiles <- t(colQuantiles(matrix, probs = probs))

82:              newQuantiles <- .returnFit(controlMatrix = model.matrix, quantiles = oldQuantiles, nPCs = nPCs)

84:              newQuantiles <- .returnFitBySex(controlMatrix = model.matrix, quantiles = oldQuantiles, nPCs = nPCs, sex = sex)

86:          .normalizeMatrix(matrix, newQuantiles)

184:         array = array))

188: ## Extraction of the Control matrix

210:     if (array=="IlluminaHumanMethylation450k"){

216:     if (array=="IlluminaHumanMethylation450k"){

322:     for (colindex in 1:ncol(model.matrix)) {

323:         if(any(is.na(model.matrix[,colindex]))) {

324:             column <- model.matrix[,colindex]

326:             model.matrix[ , colindex] <- column

331:     model.matrix <- scale(model.matrix)

334:     model.matrix[model.matrix > 3] <- 3

335:     model.matrix[model.matrix < (-3)] <- -3

338:     model.matrix <- scale(model.matrix)

340:     return(model.matrix)

346:     stopifnot(is.matrix(quantiles))

347:     stopifnot(is.matrix(controlMatrix))

355:     design <- model.matrix(~controlPCs)

363:     stopifnot(is.matrix(quantiles))

364:     stopifnot(is.matrix(controlMatrix))

406: ### Normalize a matrix of intensities

408:     ## normMatrix <- matrix(NA, nrow(intMatrix), ncol(intMatrix))

425:         result <- preprocessCore::normalize.quantiles.use.target(matrix(crtColumn.reduced), target)

345: .returnFit <- function(controlMatrix, quantiles, nPCs) {

348:     stopifnot(ncol(quantiles) == nrow(controlMatrix))

354:     controlPCs <- prcomp(controlMatrix)$x[,1:nPCs,drop=FALSE]

362: .returnFitBySex <- function(controlMatrix, quantiles, nPCs, sex) {

365:     stopifnot(ncol(quantiles) == nrow(controlMatrix))

380:         newQuantiles <- .returnFit(controlMatrix = controlMatrix,

387:         newQuantiles1 <- .returnFit(controlMatrix = controlMatrix1,

394:         newQuantiles2 <- .returnFit(controlMatrix = controlMatrix2,

411:         crtColumn <- intMatrix[ , i]

428:     return(normMatrix)

12:     .isMatrixBackedOrStop(rgSet, "preprocessFunnorm")

231:       matrix = matrices [[m]]

73:   matrix.start.lines = grep ('A\\s*[:\\|]', text)

79:   pwm.matrix = parsePWMfromText (lines)

148:     matrix.start.lines = grep ('A:', text)

153:     pwm.matrix = parsePWMfromText (lines.of.text)

157:     matrix.name <- paste(name.tokens[(token.count-1):token.count], collapse="/")

195:     matrix.name = names (matrices) [m]

33: createMatrixNameUniqifier = function (matrix)

36:   write (as.character (matrix), file=temporary.file)

52:   result = matrix (nrow=4, ncol=column.count, byrow=TRUE, dimnames=list (c ('A', 'C', 'G', 'T'), 1:column.count))

74:   stopifnot (length (matrix.start.lines) == 1)

75:   #printf ('%50s: %s', filename, list.to.string (matrix.start.lines))

76:   start.line = matrix.start.lines [1]

80:   return (pwm.matrix)

149:     stopifnot (length (matrix.start.lines) == 1)

150:     start.line = matrix.start.lines [1]

158:     matrices [[matrix.name]] = pwm.matrix

184: # and update matrix names

196:     #printf ('%d: %s', m, matrix.name)

197:     native.name.raw = gsub ('All_PWMs/', '', matrix.name)

225:       # the organism-dataSource-geneIdentifier matrix name.

232:       uniqifier = createMatrixNameUniqifier (matrix)

242:     experimentType = 'protein binding microarray'

42: } # createMatrixNameUniqifier

100:               'Compact, universal DNA microarrays...',

405:        #NBT06	5	Berger  	16998473	yeast;human;mouse	Compact, universal DNA microarrays...

20:     return Array.prototype.slice.call(pseudoarray);

5000:     var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;

5001:     chord.matrix = function(x) {

3317:   d3.interpolateArray = function(a, b) {

14:   function d3_arrayCopy(pseudoarray) {

2585:   var d3_arraySubclass = [].__proto__ ? function(array, prototype) {

15:     var i = -1, n = pseudoarray.length, array = [];

16:     while (++i < n) array.push(pseudoarray[i]);

17:     return array;

1547:   function d3_layout_stackMaxIndex(array) {

1548:     var i = 1, j = 0, v = array[0][1], k, n = array.length;

1550:       if ((k = array[i][1]) > v) {

2579:   var d3_array = d3_arraySlice;

2581:     d3_array(document.documentElement.childNodes)[0].nodeType;

2583:     d3_array = d3_arrayCopy;

2586:     array.__proto__ = prototype;

2587:   } : function(array, prototype) {

2588:     for (var property in prototype) array[property] = prototype[property];

2654:   d3.mean = function(array, f) {

2655:     var n = array.length, a, m = 0, i = -1, j = 0;

2657:       while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;

2659:       while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;

2663:   d3.median = function(array, f) {

2664:     if (arguments.length > 1) array = array.map(f);

2665:     array = array.filter(d3_number);

2666:     return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;

2668:   d3.min = function(array, f) {

2669:     var i = -1, n = array.length, a, b;

2671:       while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;

2672:       while (++i < n) if ((b = array[i]) != null && a > b) a = b;

2674:       while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;

2675:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

2679:   d3.max = function(array, f) {

2680:     var i = -1, n = array.length, a, b;

2682:       while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;

2683:       while (++i < n) if ((b = array[i]) != null && b > a) a = b;

2685:       while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;

2686:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

2690:   d3.extent = function(array, f) {

2691:     var i = -1, n = array.length, a, b, c;

2693:       while (++i < n && ((a = c = array[i]) == null || a != a)) a = c = undefined;

2694:       while (++i < n) if ((b = array[i]) != null) {

2699:       while (++i < n && ((a = c = f.call(array, array[i], i)) == null || a != a)) a = undefined;

2700:       while (++i < n) if ((b = f.call(array, array[i], i)) != null) {

2738:   d3.sum = function(array, f) {

2739:     var s = 0, n = array.length, a, i = -1;

2741:       while (++i < n) if (!isNaN(a = +array[i])) s += a;

2743:       while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;

2751:   d3.transpose = function(matrix) {

2752:     return d3.zip.apply(d3, matrix);

2756:     for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) {

2757:       for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) {

2790:   d3.first = function(array, f) {

2791:     var i = 0, n = array.length, a = array[0], b;

2794:       if (f.call(array, a, b = array[i]) > 0) {

2800:   d3.last = function(array, f) {

2801:     var i = 0, n = array.length, a = array[0], b;

2804:       if (f.call(array, a, b = array[i]) <= 0) {

2811:     function map(array, depth) {

2812:       if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;

2813:       var i = -1, n = array.length, key = keys[depth++], keyValue, object, valuesByKey = new d3_Map, values, o = {};

2815:         if (values = valuesByKey.get(keyValue = key(object = array[i]))) {

2841:     nest.map = function(array) {

2842:       return map(array, 0);

2844:     nest.entries = function(array) {

2845:       return entries(map(array, 0), 0);

2883:   d3.permute = function(array, indexes) {

2885:     while (++i < n) permutes[i] = array[indexes[i]];

2889:     return Array.prototype.concat.apply([], arrays);

2891:   d3.split = function(array, f) {

2892:     var arrays = [], values = [], value, i = -1, n = array.length;

2895:       if (f.call(values, value = array[i], i)) {

3053:         if (length < width) value = (new Array(width - length + 1)).join(fill) + value;

3060:         if (length < width) value = (new Array(width - length + 1)).join(fill) + value;

3130:     return d3_ease_clamp(m(t.apply(null, Array.prototype.slice.call(arguments, 1))));

3138:       return new d3_transform(t ? t.matrix : d3_transformIdentity);

3348:     return b instanceof Array && d3.interpolateArray(a, b);

3621:           subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i)));

3786:       value = new Array(n = (group = this[0]).length);

3899:     return typeof selector === "string" ? d3_selectionRoot.selectAll(selector) : d3_selection([ d3_array(selector) ]);

4107:     return touches ? d3_array(touches).map(function(touch) {

4937:           x += matrix[i][j];

4951:             return sortSubgroups(matrix[i][a], matrix[i][b]);

4960:           var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;

5002:       if (!arguments.length) return matrix;

5003:       n = (matrix = x) && matrix.length;

19:   function d3_arraySlice(pseudoarray) {

367:     d3_arraySubclass(groups, d3_selectionPrototype);

516:     d3_arraySubclass(selection, d3_selection_enterPrototype);

520:     d3_arraySubclass(groups, d3_transitionPrototype);

651:       point = point.matrixTransform(container.getScreenCTM().inverse());

2888:   d3.merge = function(arrays) {

2898:         if (!values.length) arrays.push(values);

2902:     return arrays;

23:   return Array.prototype.slice.call(pseudoarray);

14: var d3_array = d3_arraySlice; // conversion for NodeLists

918: d3.interpolateArray = function(a, b) {

16: function d3_arrayCopy(pseudoarray) {

32: var d3_arraySubclass = [].__proto__?

17:   var i = -1, n = pseudoarray.length, array = [];

18:   while (++i < n) array.push(pseudoarray[i]);

19:   return array;

27:   d3_array(document.documentElement.childNodes)[0].nodeType;

29:   d3_array = d3_arrayCopy;

34: // Until ECMAScript supports array subclassing, prototype injection works well.

35: function(array, prototype) {

36:   array.__proto__ = prototype;

40: function(array, prototype) {

41:   for (var property in prototype) array[property] = prototype[property];

62: d3.mean = function(array, f) {

63:   var n = array.length,

69:     while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;

71:     while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;

75: d3.median = function(array, f) {

76:   if (arguments.length > 1) array = array.map(f);

77:   array = array.filter(d3_number);

78:   return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;

80: d3.min = function(array, f) {

82:       n = array.length,

86:     while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;

87:     while (++i < n) if ((b = array[i]) != null && a > b) a = b;

89:     while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;

90:     while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

94: d3.max = function(array, f) {

96:       n = array.length,

100:     while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;

101:     while (++i < n) if ((b = array[i]) != null && b > a) a = b;

103:     while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;

104:     while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

108: d3.extent = function(array, f) {

110:       n = array.length,

115:     while (++i < n && ((a = c = array[i]) == null || a != a)) a = c = undefined;

116:     while (++i < n) if ((b = array[i]) != null) {

121:     while (++i < n && ((a = c = f.call(array, array[i], i)) == null || a != a)) a = undefined;

122:     while (++i < n) if ((b = f.call(array, array[i], i)) != null) {

147: d3.sum = function(array, f) {

149:       n = array.length,

154:     while (++i < n) if (!isNaN(a = +array[i])) s += a;

156:     while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;

171:   for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {

172:     for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {

183: // arguments lo and hi may be used to specify a subset of the array which should

184: // be considered; by default the entire array is used. If x is already present

187: // `array.splice` assuming that a is already sorted.

189: // The returned insertion point i partitions the array a into two halves so that

206: // The returned insertion point i partitions the array into two halves so that

220: d3.first = function(array, f) {

222:       n = array.length,

223:       a = array[0],

227:     if (f.call(array, a, b = array[i]) > 0) {

233: d3.last = function(array, f) {

235:       n = array.length,

236:       a = array[0],

240:     if (f.call(array, a, b = array[i]) <= 0) {

253:   function map(array, depth) {

255:         ? rollup.call(nest, array) : (sortValues

256:         ? array.sort(sortValues)

257:         : array);

260:         n = array.length,

267:       if ((keyValue = key(object = array[i])) in o) {

299:   nest.map = function(array) {

300:     return map(array, 0);

303:   nest.entries = function(array) {

304:     return entries(map(array, 0), 0);

320:   // Applies to both maps and entries array.

348: d3.permute = function(array, indexes) {

352:   while (++i < n) permutes[i] = array[indexes[i]];

356:   return Array.prototype.concat.apply([], arrays);

358: d3.split = function(array, f) {

363:       n = array.length;

366:     if (f.call(values, value = array[i], i)) {

591:       if (length < width) value = new Array(width - length + 1).join(fill) + value;

601:       if (length < width) value = new Array(width - length + 1).join(fill) + value;

716:   return d3_ease_clamp(d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1))));

966:   function(a, b) { return (b instanceof Array) && d3.interpolateArray(a, b); },

1391:         subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i)));

1813: // Note: assigning to the arguments array simultaneously changes the value of

1867:       : d3_selection([d3_array(selector)]); // assume node[]

2253:   return new d3_transform(d3_transformG.transform.baseVal.consolidate().matrix);

2958: // Converts the specified array of data into an array of points

3231: // Matrix to transform basis (b-spline) control points to bezier

3237: // Pushes a "C" Bézier curve onto the specified path array, given the

3271: // interpolation. Returns an array of tangent vectors. For details, see

3643:   return touches ? d3_array(touches).map(function(touch) {

22: function d3_arraySlice(pseudoarray) {

355: d3.merge = function(arrays) {

359:   var arrays = [],

369:       if (!values.length) arrays.push(values);

373:   return arrays;

1331:   d3_arraySubclass(groups, d3_selectionPrototype);

1870:   d3_arraySubclass(selection, d3_selection_enterPrototype);

1905:   d3_arraySubclass(groups, d3_transitionPrototype);

3238: // two specified four-element arrays which define the control points.

3637:   point = point.matrixTransform(container.getScreenCTM().inverse());

183: 		int matrix[MAX_AA][MAX_AA];

173: typedef Vector<VectorInt> MatrixInt;

176: typedef Vector<VectorInt64> MatrixInt64;

179: class ScoreMatrix { //Matrix

197: typedef Vector<VectorIntX> MatrixIntX;

189: 		void set_matrix(int *mat1);

212: extern int NAAN_array[13];

45: #include<valarray>

95: // std::valarray could be used instead of std::vector.

186: 		ScoreMatrix();

193: }; // END class ScoreMatrix

476: 	MatrixInt64  score_mat;

477: 	MatrixInt    back_mat;

531: extern ScoreMatrix  mat;

606: int local_band_align( char query[], char ref[], int qlen, int rlen, ScoreMatrix &mat,

6015:             matrix <- gcl$vmap[rev(gcl$row.order), results$hvc$order, drop = FALSE]

6083:                        matrix <- results$rcm[rev(results$tvc$order), results$hvc$order]

6324:                        matrix <- results$rcm[rev(results$tvc$order), results$hvc$order]

1079: winsorize.matrix <- function(mat, trim) {

3405: calculate.joint.posterior.matrix <- function(lmatl, n.samples = 100, bootstrap = TRUE, n.cores = 15) {

3422: calculate.batch.joint.posterior.matrix <- function(lmatll, composition, n.samples = 100, n.cores = 15) {

3810: get.exp.posterior.matrix <- function(m1, counts, marginals, grid.weight = rep(1, nrow(marginals)), rescale = TRUE, n.cores =...(17 bytes skipped)...

3826: get.exp.logposterior.matrix <- function(m1, counts, marginals, grid.weight = rep(1, nrow(marginals)), rescale = TRUE, n.cores =...(6 bytes skipped)...

109: ##' Filter counts matrix

111: ##' Filter counts matrix based on gene and cell requirements

113: ##' @param counts read count matrix. The rows correspond to genes, columns correspond to individual cells

118: ##' @return a filtered read count matrix

145: ##' @param counts read count matrix. The rows correspond to genes (should be named), columns correspond to individual cells. The matrix should contain integer counts

163: ##' @return a model matrix, with rows corresponding to different cells, and columns representing different parameters of the d...(16 bytes skipped)...

184: ...(114 bytes skipped)...thod is designed to work on read counts - do not pass normalized read counts (e.g. FPKM values). If matrix contains read counts, but they are stored as numeric values, use counts<-apply(counts,2,function(x)...(49 bytes skipped)...

208: ##' @param counts count matrix

228:     fpkm <- log10(exp(as.matrix(fpkm))+1)

229:     wts <- as.numeric(as.matrix(1-fail[, colnames(fpkm)]))

262: ##' @param counts read count matrix

264: ...(41 bytes skipped)...e two groups of cells being compared. The factor entries should correspond to the rows of the model matrix. The factor should have two levels. NAs are allowed (cells will be omitted from comparison).

265: ##' @param batch a factor (corresponding to rows of the model matrix) specifying batch assignment of each cell, to perform batch correction

284: ##' \code{difference.posterior} returns a matrix of estimated expression difference posteriors (rows - genes, columns correspond to different magnit...(64 bytes skipped)...

305:         stop("ERROR: provided count data does not cover all of the cells specified in the model matrix")

309:     counts <- as.matrix(counts[, ci])

416: ##' @param models model matrix

417: ##' @param counts count matrix

513: ##' @param counts read count matrix

516: ##' @param batch a factor describing which batch group each cell (i.e. each row of \code{models} matrix) belongs to

523: ##' @return \subsection{default}{ a posterior probability matrix, with rows corresponding to genes, and columns to expression levels (as defined by \code{prior$x})

525: ...(24 bytes skipped)...ndividual.posterior.modes}{ a list is returned, with the \code{$jp} slot giving the joint posterior matrix, as described above. The \code{$modes} slot gives a matrix of individual expression posterior mode values on log scale (rows - genes, columns -cells)}

526: ...(85 bytes skipped)...st} slot giving a list of individual posterior matrices, in a form analogous to the joint posterior matrix, but reported on log scale }

538: ...(43 bytes skipped)...counts))) { stop("ERROR: provided count data does not cover all of the cells specified in the model matrix") }

545:     counts <- as.matrix(counts[, ci, drop = FALSE])

571:     # prepare matrix models

574:     mm <- matrix(NA, nrow(models), length(mn))

575:     mm[, which(!is.na(mc))] <- as.matrix(models[, mc[!is.na(mc)], drop = FALSE])

645: # models - entire model matrix, or a subset of cells (i.e. select rows) of the model matrix for which the estimates should be obtained

647: # return - a matrix of log(FPM) estimates with genes as rows and cells  as columns (in the model matrix order).

653: ##' @param counts count matrix

655: ##' @return a matrix of expression magnitudes on a log scale (rows - genes, columns - cells)

666: ...(43 bytes skipped)...counts))) { stop("ERROR: provided count data does not cover all of the cells specified in the model matrix") }

672: # magnitudes can either be a per-cell matrix or a single vector of values which will be evaluated for each cell

676: ##' Returns estimated drop-out probability for each cell (row of \code{models} matrix), given either an expression magnitude

678: ##' @param magnitudes a vector (\code{length(counts) == nrows(models)}) or a matrix (columns correspond to cells) of expression magnitudes, given on a log scale

679: ##' @param counts a vector (\code{length(counts) == nrows(models)}) or a matrix (columns correspond to cells) of read counts from which the expression magnitude should be estimate...(1 bytes skipped)...

681: ##' @return a vector or a matrix of drop-out probabilities

704:     if(is.matrix(magnitudes)) { # a different vector for every cell

705: ...(55 bytes skipped)...es))) { stop("ERROR: provided magnitude data does not cover all of the cells specified in the model matrix") }

730: ##' @param counts read count matrix (must contain the row corresponding to the specified gene)

732: ##' @param groups a two-level factor specifying between which cells (rows of the models matrix) the comparison should be made

733: ##' @param batch optional multi-level factor assigning the cells (rows of the model matrix) to different batches that should be controlled for (e.g. two or more biological replicates). The e...(224 bytes skipped)...

759:     counts <- as.matrix(counts[gene, ci, drop = FALSE])

819:         layout(matrix(c(1:3), 3, 1, byrow = TRUE), heights = c(2, 1, 2), widths = c(1), FALSE)

926: ##' @param counts count matrix

927: ...(8 bytes skipped)...am reference a vector of expression magnitudes (read counts) corresponding to the rows of the count matrix

936: ##' @return matrix of scde models

988:         #l <- layout(matrix(seq(1, 4*length(ids)), nrow = length(ids), byrow = TRUE), rep(c(1, 1, 1, 0.5), length(ids)), rep(1,...(23 bytes skipped)...

989:         l <- layout(matrix(seq(1, 4), nrow = 1, byrow = TRUE), rep(c(1, 1, 1, 0.5), 1), rep(1, 4), FALSE)

1000:         # make a joint model matrix

1011: ##' Determine principal components of a matrix using per-observation/per-variable weights

1015: ##' @param mat matrix of variables (columns) and observations (rows)

1026: ##' @return a list containing eigenvector matrix ($rotation), projections ($scores), variance (weighted) explained by each component ($var), total (...(45 bytes skipped)...

1030: ##' mat <- matrix( c(rnorm(5*10,mean=0,sd=1), rnorm(5*10,mean=5,sd=1)), 10, 10)  # random matrix

1032: ##' matw <- matrix( c(rnorm(5*10,mean=0,sd=1), rnorm(5*10,mean=5,sd=1)), 10, 10)  # random weight matrix

1040:       stop("bwpca: weight matrix contains NaN values")

1043:       stop("bwpca: value matrix contains NaN values")

1046:         matw <- matrix(1, nrow(mat), ncol(mat))

1061: ##' Winsorize matrix

1065: ##' @param mat matrix

1068: ##' @return Winsorized matrix

1072: ##' mat <- matrix( c(rnorm(5*10,mean=0,sd=1), rnorm(5*10,mean=5,sd=1)), 10, 10)  # random matrix

1075: ##' win.mat <- winsorize.matrix(mat, 0.1)

1100: ##' @param counts count matrix (integer matrix, rows- genes, columns- cells)

1133: ...(114 bytes skipped)...thod is designed to work on read counts - do not pass normalized read counts (e.g. FPKM values). If matrix contains read counts, but they are stored as numeric values, use counts<-apply(counts,2,function(x)...(49 bytes skipped)...

1162:         #celld <- WGCNA::cor(log10(matrix(as.numeric(as.matrix(ca)), nrow = nrow(ca), ncol = ncol(ca))+1), method = cor.method, use = "p", nThreads = n.cores)

1164:             celld <- WGCNA::cor(sqrt(matrix(as.numeric(as.matrix(ca[, ids])), nrow = nrow(ca), ncol = length(ids))), method = cor.method, use = "p", nThreads = n.co...(4 bytes skipped)...

1166:             celld <- stats::cor(sqrt(matrix(as.numeric(as.matrix(ca[, ids])), nrow = nrow(ca), ncol = length(ids))), method = cor.method, use = "p")

1174:         # TODO: correct for batch effect in cell-cell similarity matrix

1176:             # number batches 10^(seq(0, n)) compute matrix of id sums, NA the diagonal,

1178:             bm <- matrix(bid, byrow = TRUE, nrow = length(bid), ncol = length(bid))+bid

1181:             # use tapply to calculate means shifts per combination reconstruct shift vector, matrix, subtract

1239:                     l <- layout(matrix(seq(1, 4), nrow = 1, byrow = TRUE), rep(c(1, 1, 1, ifelse(local.theta.fit, 1, 0.5)), 1), rep(1, 4),...(7 bytes skipped)...

1263:     # make a joint model matrix

1278: ##' @param models model matrix (select a subset of rows to normalize variance within a subset of cells)

1279: ##' @param counts read count matrix

1288: ##' @param weight.k k value to use in the final weight matrix

1294: ##' @param gene.length optional vector of gene lengths (corresponding to the rows of counts matrix)

1307: ##' \item{matw} { weight matrix corresponding to the expression matrix}

1334:         stop(paste("supplied count matrix (cd) is missing data for the following cells:[", paste(rownames(models)[!rownames(models) %in% coln...(44 bytes skipped)...

1343:         if(verbose) { cat("Winsorizing count matrix ... ") }

1345:         #tfpm <- log(winsorize.matrix(exp(fpm), trim = trim))

1346:         tfpm <- winsorize.matrix(fpm, trim)

1430:     if(verbose) { cat("calculating weight matrix ... ") }

1450:     # calculate batch-specific version of the weight matrix if needed

1695:     # use milder weight matrix

1787: ##' (weighted) projection of the expression matrix onto a specified aspect (some pattern

1794: ##' @param center whether the matrix should be re-centered following pattern subtraction

1796: ##' @return a modified varinfo object with adjusted expression matrix (varinfo$mat)

1850: ##' @param center whether the expression matrix should be recentered

1989: ##' Determine de-novo gene clusters, their weighted PCA lambda1 values, and random matrix expectation.

1995: ##' @param n.samples number of randomly generated matrix samples to test the background distribution of lambda1 on

2004: ...(10 bytes skipped)... secondary.correlation whether clustering should be performed on the correlation of the correlation matrix instead

2014: ##' \item{varm} {standardized lambda1 values for each randomly generated matrix cluster}

2036:         mat <- winsorize.matrix(mat, trim = trim)

2060:                 gd <- as.dist(1-WGCNA::cor(as.matrix(gd), method = "p", nThreads = n.cores))

2062:                 gd <- as.dist(1-cor(as.matrix(gd), method = "p"))

2103:                 # generate random normal matrix

2105:                 m <- matrix(rnorm(nrow(mat)*n.cells), nrow = nrow(mat), ncol = n.cells)

2113:                     m <- winsorize.matrix(m, trim = trim)

2124:                         gd <- as.dist(1-WGCNA::cor(as.matrix(gd), method = "p", nThreads = 1))

2126:                         gd <- as.dist(1-cor(as.matrix(gd), method = "p"))

2230: ##' \item{xv} {a matrix of normalized aspect patterns (rows- significant aspects, columns- cells}

2231: ##' \item{xvw} { corresponding weight matrix }

2505: ##' @param distance distance matrix

2569:     if(trim > 0) { xvl$d <- winsorize.matrix(xvl$d, trim) } # trim prior to determining the top sets

2593: ...(35 bytes skipped)...f whether to return just the hclust result or a list containing the hclust result plus the distance matrix and gene values

2690: ##' @param mat Numeric matrix

2694: ##' @param row.cols  Matrix of row colors.

2695: ##' @param col.cols  Matrix of column colors. Useful for visualizing cell annotations such as batch labels.

2730: ##' @param col.cols  Matrix of column colors. Useful for visualizing cell annotations such as batch labels. Default NULL.

2840:         layout(matrix(c(1:3), 3, 1, byrow = TRUE), heights = c(2, 1, 2), widths = c(1), FALSE)

2953:                 m1@concomitant@x <- matrix()

2955:                     mod@x <- matrix()

2956:                     mod@y <- matrix()

3083: # vil - optional binary matrix (corresponding to counts) with 0s marking likely drop-out observations

3118:     f <- calcNormFactors(as.matrix(counts[gis, !is.na(groups)]), ...)

3127:     fpkm <- log10(exp(as.matrix(fpkm))+1)

3128:     wts <- as.numeric(as.matrix(1-fail[, colnames(fpkm)]))

3218:         # pair cell name matrix

3267:             m1@concomitant@x <- matrix()

3269:                 mod@x <- matrix()

3270:                 mod@y <- matrix()

3327:             #l <- layout(matrix(seq(1, 4*length(ids)), nrow = length(ids), byrow = TRUE), rep(c(1, 1, 1, 0.5), length(ids)), rep(1,...(23 bytes skipped)...

3328:             l <- layout(matrix(seq(1, 4), nrow = 1, byrow = TRUE), rep(c(1, 1, 1, ifelse(linear.fit, 1, 0.5)), 1), rep(1, 4), FALS...(2 bytes skipped)...

3344:         # make a joint model matrix

3360: # gets an array summary of gam model structure (assumes a flat ifm list)

3386:             df <- get.exp.logposterior.matrix(group.ifm[[nam]], dat[, nam], marginals, n.cores = inner.cores, grid.weight = prior$grid.weight)

3403: # calculate joint posterior matrix for a given group of experiments

3420: # lmatll - list of posterior matrix lists (as obtained from calculate.posterior.matrices)

3467: # calculate a joint posterior matrix with bootstrap

3589:     #matrix(cbind(ifelse(rdf$count<= zero.count.threshold, 0.95, 0.05), ifelse(rdf$count > zero.count.threshold...(15 bytes skipped)...

3604:         l <- layout(matrix(c(1:4), 1, 4, byrow = TRUE), c(1, 1, 1, 0.5), rep(1, 4), FALSE)

3654:     fdf <- data.frame(y = rowMeans(matrix(log10(rdf$fpm[1:(n.zero.windows*bw)]+1), ncol = bw, byrow = TRUE)), zf = rowMeans(matrix(as.integer(rdf$cluster[1:(n.zero.windows*bw)] == 1), ncol = bw, byrow = TRUE)))

3663:         cm0 <- exp(model.matrix(mt, data = mf) %*% m1@concomitant@coef)

3716: # df: count matrix

3717: # xr: expression level for each row in the matrix

3740: # counts - observed count matrix corresponding to the models

3780:     cm0 <- exp(model.matrix(mt, data = mf) %*% m1@concomitant@coef)

3797:     cm0 <- model.matrix(mt, data = mf) %*% m1@concomitant@coef

3805: # returns a matrix of posterior values, with rows corresponding to genes, and

3812:     #message(paste("get.exp.posterior.matrix() :", round((1-length(uc)/length(counts))*100, 3), "% savings"))

3828:     #message(paste("get.exp.logposterior.matrix() :", round((1-length(uc)/length(counts))*100, 3), "% savings"))

3841: # similar to get.exp.posterior.matrix(), but returns inverse ecdf list

3848: # similar to get.exp.posterior.matrix(), but returns inverse ecdf list

3871:     cm0 <- exp(model.matrix(mt, data = mf) %*% m1@concomitant@coef)

4138:         m <- matrix(sapply(components, function(x) x@logLik(model@x, model@y)), nrow = nrow(model@y))

4141:         m <- matrix(do.call(cbind, lapply(seq_along(components), function(i) {

4175:         m <- matrix(sapply(components, function(x) x@logLik(model@x, model@y)), nrow = nrow(model@y))

4178:         m <- matrix(do.call(cbind, lapply(seq_along(components), function(i) {

4223:         m <- matrix(sapply(components, function(x) x@logLik(model@x, model@y)), nrow = nrow(model@y))

4226:         m <- matrix(do.call(cbind, lapply(seq_along(components), function(i) {

4488:     x <- as.matrix(x)

4490:     ynames <- if (is.matrix(y))

4611:                 stop(gettextf("X matrix has rank %d, but only %d observations",

4711:         fit$qr <- as.matrix(fit$qr)

4718:         Rmat <- as.matrix(Rmat)

4856:     if (!is.matrix(x)) {

5008: # weight matrix should have the same dimensions as the data matrix

5154:         stop("'x' must be a numeric matrix")

5259:         if(is.matrix(ColSideColors)) {

5261:                 stop("'ColSideColors' matrix must have the same number of columns as length ncol(x)")

5306:         if(is.matrix(ColSideColors)) {

5307:             image(t(matrix(1:length(ColSideColors), byrow = TRUE, nrow = nrow(ColSideColors), ncol = ncol(ColSideColors))), co...(70 bytes skipped)...

5572:         mat <- winsorize.matrix(mat, trim = trim)

5583:     dd <- as.dist(1-abs(cor(t(as.matrix(d)))))

5599:         vd <- as.dist(1-cor(as.matrix(d)))

5669: ##' @param colcols optional column color matrix

5678: ##' @param box whether to draw a box around the plotted matrix

5680: ##' @param return.details whether the function should return the matrix as well as full PCA info instead of just PC1 vector

5726:         mat <- winsorize.matrix(mat, trim = trim)

5766:             mat <- winsorize.matrix(mat, trim = trim)

5791:     dd <- as.dist(1-abs(cor(t(as.matrix(d)))))

5807:         vd <- as.dist(1-cor(as.matrix(d)))

5973: ##' @field mat Matrix of posterior mode count estimates

5974: ##' @field matw Matrix of weights associated with each estimate in \code{mat}

6016:             matrix <- list(data = as.numeric(t(matrix)),

6017:                            dim = dim(matrix),

6018:                            rows = rownames(matrix),

6019:                            cols = colnames(matrix),

6024:             ol <- list(matrix = matrix)

6026:                 rcmvar <- matrix(gcl$rotation[rev(gcl$row.order), , drop = FALSE], ncol = 1)

6033:                 colcols <- matrix(gcl$oc[results$hvc$order], nrow = 1)

6084:                        matrix <- list(data = as.numeric(t(matrix)),

6085:                                       dim = dim(matrix),

6086:                                       rows = rownames(matrix),

6087:                                       cols = colnames(matrix),

6090:                                       range = range(matrix)

6095:                        rcmvar <- matrix(apply(results$rcm[rev(results$tvc$order), , drop = FALSE], 1, var), ncol = 1)

6105:                        ol <- list(matrix = matrix, rowcols = rowcols, colcols = colcols, coldend = treeg, trim = trim)

6159:                        patc <- .Call("matCorr", as.matrix(t(mat)), as.matrix(pat, ncol = 1) , PACKAGE = "scde")

6325:                        body <- paste(capture.output(write.table(round(matrix, 1), sep = "\t")), collapse = "\n")

1081:     wm <- .Call("winsorizeMatrix", mat, trim, PACKAGE = "scde")

1755:         ##   # construct mat multiplier submatrix

3723:         x <- FLXgetModelmatrix(m1@model[[1]], edf, m1@model[[1]]@formula)

3724:         #cx <- FLXgetModelmatrix(m1@concomitant, edf, m1@concomitant@formula)

6188:     chord.matrix = function(x) {

5:   var d3_arraySlice = [].slice, d3_array = function(list) {

5798:   function d3_interpolateArray(a, b) {

17:       d3_array(d3_document.documentElement.childNodes)[0].nodeType;

19:       d3_array = function(list) {

20:         var i = list.length, array = new Array(i);

21:         while (i--) array[i] = list[i];

22:         return array;

52:   d3.min = function(array, f) {

53:     var i = -1, n = array.length, a, b;

55:       while (++i < n) if ((b = array[i]) != null && b >= b) {

59:       while (++i < n) if ((b = array[i]) != null && a > b) a = b;

61:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {

65:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

69:   d3.max = function(array, f) {

70:     var i = -1, n = array.length, a, b;

72:       while (++i < n) if ((b = array[i]) != null && b >= b) {

76:       while (++i < n) if ((b = array[i]) != null && b > a) a = b;

78:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {

82:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

86:   d3.extent = function(array, f) {

87:     var i = -1, n = array.length, a, b, c;

89:       while (++i < n) if ((b = array[i]) != null && b >= b) {

93:       while (++i < n) if ((b = array[i]) != null) {

98:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b >= b) {

102:       while (++i < n) if ((b = f.call(array, array[i], i)) != null) {

115:   d3.sum = function(array, f) {

116:     var s = 0, n = array.length, a, i = -1;

118:       while (++i < n) if (d3_numeric(a = +array[i])) s += a;

120:       while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a;

124:   d3.mean = function(array, f) {

125:     var s = 0, n = array.length, a, i = -1, j = n;

127:       while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j;

129:       while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j;

137:   d3.median = function(array, f) {

138:     var numbers = [], n = array.length, a, i = -1;

140:       while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a);

142:       while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a);

146:   d3.variance = function(array, f) {

147:     var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0;

150:         if (d3_numeric(a = d3_number(array[i]))) {

158:         if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) {

201:   d3.shuffle = function(array, i0, i1) {

203:       i1 = array.length;

209:       t = array[m + i0], array[m + i0] = array[i + i0], array[i + i0] = t;

211:     return array;

213:   d3.permute = function(array, indexes) {

214:     var i = indexes.length, permutes = new Array(i);

215:     while (i--) permutes[i] = array[indexes[i]];

218:   d3.pairs = function(array) {

219:     var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);

220:     while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];

223:   d3.transpose = function(matrix) {

224:     if (!(n = matrix.length)) return [];

225:     for (var i = -1, m = d3.min(matrix, d3_transposeLength), transpose = new Array(m); ++i < m; ) {

226:       for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n; ) {

227:         row[j] = matrix[j][i];

257:     var n = arrays.length, m, i = -1, j = 0, merged, array;

259:     merged = new Array(j);

261:       array = arrays[n];

262:       m = array.length;

264:         merged[--j] = array[m];

303:     } else if (Array.isArray(object)) {

372:     function map(mapType, array, depth) {

373:       if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;

374:       var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;

376:         if (values = valuesByKey.get(keyValue = key(object = array[i]))) {

398:       var array = [], sortKey = sortKeys[depth++];

400:         array.push({

405:       return sortKey ? array.sort(function(a, b) {

407:       }) : array;

409:     nest.map = function(array, mapType) {

410:       return map(mapType, array, 0);

412:     nest.entries = function(array) {

413:       return entries(map(d3.map, array, 0), 0);

433:   d3.set = function(array) {

435:     if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);

611:           subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));

833:       value = new Array(n = (group = this[0]).length);

842:       var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;

844:         var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue;

974:     var args = d3_array(arguments);

1054:       group = d3_array(d3_selectAll(nodes, d3_document));

1057:       group = d3_array(nodes);

1088:       var l = wrap(listener, d3_array(arguments));

1255:     return touches ? d3_array(touches).map(function(touch) {

1985:         return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));

2094:       if (Array.isArray(rows[0])) return dsv.formatRows(rows);

2295: ...(31 bytes skipped)...gth + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";

2734:     return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);

3296:   function d3_geo_clipPolygonLinkCircular(array) {

3297:     if (!(n = array.length)) return;

3298:     var n, i = 0, a = array[0], b;

3300:       a.n = b = array[i];

3304:     a.n = b = array[0];

5448:     d3_geom_voronoiCells = new Array(sites.length);

5481:       var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[...(6 bytes skipped)...

5795: ...(83 bytes skipped).../i.test(b) ? d3_interpolateRgb : d3_interpolateString : b instanceof d3_color ? d3_interpolateRgb : Array.isArray(b) ? d3_interpolateArray : t === "object" && isNaN(b) ? d3_interpolateObject : d3_interpolateNumber)(a, b);

5952:       return new d3_transform(t ? t.matrix : d3_transformIdentity);

6116:     var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;

6125:           x += matrix[i][j];

6139:             return sortSubgroups(matrix[i][a], matrix[i][b]);

6148:           var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;

6189:       if (!arguments.length) return matrix;

6190:       n = (matrix = x) && matrix.length;

6413:           neighbors = new Array(n);

6818:   function d3_layout_stackMaxIndex(array) {

6819:     var i = 1, j = 0, v = array[0][1], k, n = array.length;

6821:       if ((k = array[i][1]) > v) {

9031:       tickArguments_ = d3_array(arguments);

6:     return d3_arraySlice.call(list);

256:   d3.merge = function(arrays) {

258:     while (++i < n) j += arrays[i].length;

1187:       point = point.matrixTransform(container.getScreenCTM().inverse());

5797:   d3.interpolateArray = d3_interpolateArray;

5847:     return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1))));

9142:             var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y);

42:     int* array;//array where counts are stored

32: class GArray {

44:     GArray(int _rid, int _loc, int _len, int _strand){

30: //genomic array: represents a correspondence between a genomic range and

43:     int alen;//num of elements of the array

147:     //allocate a list with one vector (or matrix) containing all counts

164:             ranges[i].array = C + mult*i;

177:             //if strand specific, allocate matrix

181:             ranges[i].array = sig.begin(); 

186:             ranges[i].array = sig.begin(); 

360:         //even positions of the array are sense-reads, odd are antisense

361:         if (ss){ ++range.array[2*(relpos/binsize) + antisense]; }

362:         else {++range.array[relpos/binsize]; } 

424:             ++range.array[pos>0?pos:0];

427:                 --range.array[pos];

432:             ++range.array[pos>0?pos:0];

435:                 --range.array[pos];

491:         cumsum(ranges[i].array, ranges[i].len);

92: void parseRegions(std::vector<GArray>& container, RObject& gr, samFile* in){

131:         container.push_back(GArray(rid, starts[i] - 1, lens[i], strand));

137: //allocates the memory and sets the pointer for each GArray object

139: static List allocateList(std::vector<GArray>& ranges, int* binsize, bool ss){

152:           IntegerMatrix sig(2, rnum);

178:             IntegerMatrix sig(2, width);

222: static inline bool sortByStart(const GArray& a, const GArray& b){

236: //2. void pileup(GArray&): pileup the last set read with the given interval

241: static void overlapAndPileup(Bamfile& bfile, std::vector<GArray>& ranges, 

349:     inline void pileup(GArray& range){

418:     inline void pileup(GArray& range){

447:     std::vector<GArray> ranges;

477:     std::vector<GArray> ranges;

115:             matrix <- apply(quantiles, 2, function(x){

119:             matrix.x <- matrix[1:512,]

120:             matrix.y <- matrix[513:(2*512),]

242:                 density.matrix <- returnDensityMatrix()

243:                 x.matrix <- density.matrix[[1]]

244:                 y.matrix <- density.matrix[[2]]

27:         arrayNames      <- substr(sampleNames,12,17)

105:     returnDensityMatrix <- reactive({

125:     returnDensityMatrixNorm <- reactive({

121:             return(list(matrix.x = matrix.x, matrix.y = matrix.y))

139:             matrix <- apply(quantiles, 2, function(x){

143:             matrix.x <- matrix[1:512,]

144:             matrix.y <- matrix[513:(2*512),]

145:             return(list(matrix.x = matrix.x, matrix.y = matrix.y))  

245:                 x.matrix <- ((x.matrix - mouse.x)/range.x)^2

246:                 y.matrix <- ((y.matrix - mouse.y)/range.y)^2

247:                 clickedIndex <- arrayInd(which.min(x.matrix+y.matrix),

248:                                          c(512,ncol(x.matrix)))[2]

285:                 density.matrix <- returnDensityMatrixNorm()

286:                 x.matrix <- density.matrix[[1]]

287:                 y.matrix <- density.matrix[[2]]

288:                 x.matrix <- ((x.matrix - mouse.x)/range.x)^2

289:                 y.matrix <- ((y.matrix - mouse.y)/range.y)^2

290:                 clickedIndex <- arrayInd(which.min(x.matrix+y.matrix),

291:                                          c(512,ncol(x.matrix)))[2]

378:             densitiesPlot(matrix.x = returnDensityMatrix()[[1]],

379:                           matrix.y = returnDensityMatrix()[[2]],

391:                                 matrix.x = returnDensityMatrix()[[1]],

392:                                 matrix.y = returnDensityMatrix()[[2]],

445:         densitiesPlot(matrix.x = returnDensityMatrixNorm()[[1]],

446:                               matrix.y = returnDensityMatrixNorm()[[2]],

458:                                     matrix.x = returnDensityMatrixNorm()[[1]],

459:                                     matrix.y = returnDensityMatrixNorm()[[2]],

635:             matrix <- apply(betaQuantiles[[index]], 2, function(x){

639:             matrix.x <- matrix[1:512,]

640:             matrix.y <- matrix[513:(2*512),]

648:             densitiesPlot(matrix.x = matrix.x,

649:                           matrix.y = matrix.y,

711:         output$arrayDesign <- renderPlot({

717:         output$arrayDesignLegend <- renderPlot({

900:     matrix = NULL

1013:     as.adj.matrix(x,

1289:     as.adj.matrix(x,

646: as.adj.matrix <- function(x,

916:     matrix.to.df <- function(m) {    

1035:     matrix.to.df <- function(z) {   

1213:     matrix.to.df <- function(z) {   

1217:         prederr.matrix = x$kfold[[z]]$prederr

1297:     matrix.to.df <- function(z) {  

1303:         posterr.matrix = get(z, x$kfold)$posterr

1967:     adj.matrix = get(model, as.adj.matrix(x, models = model))

21: #' @return A TRONCO genotypes matrix.

87: #' @return A matrix with 2 columns (event type, gene name) for the events found.

121: #' @return A matrix with 1 column annotating stages and rownames as sample IDs.

143: #' @return A matrix with 1 column annotating stages and rownames as sample IDs.

180: #' @return A matrix, subset of \code{as.genotypes(x)} with colnames substituted  with events' types.

627: #' Extract the adjacency matrix of a TRONCO model. The matrix is indexed with colnames/rownames which 

629: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

630: #' been performed. Also, either the prima facie matrix or the post-regularization matrix can be extracted.

634: #' as.adj.matrix(test_model)

635: #' as.adj.matrix(test_model, events=as.events(test_model)[5:15,])

636: #' as.adj.matrix(test_model, events=as.events(test_model)[5:15,], type='pf')

638: #' @title as.adj.matrix

642: #' @param type Either the prima facie ('pf') or the post-regularization ('fit') matrix, 'fit' by default.

643: #' @return The adjacency matrix of a TRONCO model. 

644: #' @export as.adj.matrix

667:             mat = m[[i]]$adj.matrix$adj.matrix.fit

669:             mat = m[[i]]$adj.matrix$adj.matrix.pf

683: #' Extract the marginal probabilities from a TRONCO model. The return matrix is indexed with rownames which 

685: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

709:         stop('Events should have colnames to access the adjacency matrix - use \'as.events\' function?')

734: #' Extract the joint probabilities from a TRONCO model. The return matrix is indexed with rownames/colnames which 

736: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

761:         stop('Events should have colnames to access the adjacency matrix - use \'as.events\' function?')

787: #' Extract the conditional probabilities from a TRONCO model. The return matrix is indexed with rownames which 

789: #' specify a subset of events to build the matrix, a subset of models if multiple reconstruction have

814:         stop('Events should have colnames to access the adjacency matrix - use \'as.events\' function?')

903:         matrix$pf = x$adj.matrix.prima.facie   

905:         matrix =

906:             as.adj.matrix(x,

911:     matrix = lapply(matrix, keysToNames, x = x)

981:     return(lapply(matrix, matrix.to.df))

1012:     matrix = 

1019:     matrix = lapply(matrix, keysToNames, x = x)

1036:         m = matrix[[z]]

1117:     res = lapply(seq_along(matrix), matrix.to.df)

1118:     names(res) = names(matrix)

1219:             names(prederr.matrix) = lapply(names(prederr.matrix), function(k) { nameToKey(x, k) })

1220:             return(prederr.matrix)

1225:         df$prederr = t(as.data.frame(prederr.matrix)) # values

1248:     res = lapply(seq_along(models), matrix.to.df)

1288:     matrix = 

1295:     matrix = lapply(matrix, keysToNames, x = x)

1302:         m = matrix[[z]]

1306:             rownames(posterr.matrix) = lapply(rownames(posterr.matrix), function(k) { nameToKey(x, k) })

1307:             colnames(posterr.matrix) = lapply(colnames(posterr.matrix), function(k) { nameToKey(x, k) })

1308:             return(posterr.matrix)

1312:         posterr.matrix = keysToNames(posterr.matrix, x = x)

1333:                     val = posterr.matrix[[select,selected]]

1369:     res = lapply(models, matrix.to.df)

1370:     names(res) = names(matrix)

1802: #' Convert colnames/rownames of a matrix into intelligible event names, e.g., change a key G23 in 'Mutation KRAS'.

1807: #' adj_matrix = as.adj.matrix(test_model, events=as.events(test_model)[5:15,])$capri_bic

1808: #' keysToNames(test_model, adj_matrix)

1813: #' @param matrix A matrix with colnames/rownames which represent genotypes keys. 

1814: #' @return The matrix with intelligible colnames/rownames. 

1817: keysToNames <- function(x, matrix) {

1819:     if (!is.matrix(matrix)

1820:         || any(is.null(colnames(matrix)))

1821:         || any(is.null(rownames(matrix))))

1822:         stop('"matrix" should be a matrix with rownames/colnames.')

1830:     colnames(matrix) = sapply(colnames(matrix), resolve)

1831:     rownames(matrix) = sapply(rownames(matrix), resolve)

1832:     return(matrix)

1840: #' adj_matrix = as.adj.matrix(test_model, events=as.events(test_model)[5:15,])$bic

1908:     data = array("missing", c(nrow(dataset), ncol(dataset)))

1961:     genotypes = as.matrix(genotypes)

1968:     adj.matrix = keysToNames(x, adj.matrix)

1975:     for (from in rownames(adj.matrix)) {

1976:         for (to in colnames(adj.matrix)) {

1977:             if (adj.matrix[from, to] == 1) {

199:     array <- annotation(rgSet)[["array"]]

236:     array <- extractedData$array

151:         n_matrix <- .normalizeMatrix(mat_auto, newQuantiles)

161:     model.matrix <- .buildControlMatrix450k(extractedData)

352:     model.matrix <- cbind(

447: .normalizeMatrix <- function(intMatrix, newQuantiles) {

450:     normMatrix <- sapply(1:ncol(intMatrix), function(i) {

228: .buildControlMatrix450k <- function(extractedData) {

424:         controlMatrix1 <- controlMatrix[sex == levels[1], ]

431:         controlMatrix2 <- controlMatrix[sex == levels[2], ]

480: .isMatrixBackedOrStop <- function(object, FUN) {

488: .isMatrixBacked <- function(object) {

1: ...(2 bytes skipped)...# ORIGINAL AUTHOR: Jean-Philippe Fortin, Sept 24 2013 (Functional normalization of 450k methylation array data improves replication in large cancer studies, Genome Biology, 2014)

5: ## Functional normalization of the 450k array

38: #' Functional normalization of 450k methylation array data improves replication 

117:     #normalizeQuantiles <- function(matrix, indices, sex = NULL) {

118:     #    matrix <- matrix[indices,,drop=FALSE]

119:     #    ## uses probs, model.matrix, nPCS, through scoping)

120:     #    oldQuantiles <- t(colQuantiles(matrix, probs = probs))

122:     #        newQuantiles <- .returnFit(controlMatrix = model.matrix, quantiles = oldQuantiles, nPCs = nPCs)

124:     #        newQuantiles <- .returnFitBySex(controlMatrix = model.matrix, quantiles = oldQuantiles, nPCs = nPCs, sex = sex)

126:     #    .normalizeMatrix(matrix, newQuantiles)

148:         ## uses probs, model.matrix, nPCS, through scoping)

150:         newQuantiles <- .returnFit(controlMatrix = model.matrix, quantiles = oldQuantiles, nPCs = nPCs)

152:         for(j in 1:ncol(n_matrix)){

153:             mat_sex[, j] <- interpolatedXY(mat_auto[, j], n_matrix[, j], mat_sex[, j])

156:         mat[(indices & !sex_probe), ] <- n_matrix

223:         array = array))

227: ## Extraction of the Control matrix

249:     if (array=="IlluminaHumanMethylation450k"){

255:     if (array=="IlluminaHumanMethylation450k"){

361:     for (colindex in 1:ncol(model.matrix)) {

362:         if(any(is.na(model.matrix[,colindex]))) {

363:             column <- model.matrix[,colindex]

365:             model.matrix[ , colindex] <- column

370:     model.matrix <- scale(model.matrix)

373:     model.matrix[model.matrix > 3] <- 3

374:     model.matrix[model.matrix < (-3)] <- -3

377:     model.matrix <- scale(model.matrix)

379:     return(model.matrix)

385:     stopifnot(is.matrix(quantiles))

386:     stopifnot(is.matrix(controlMatrix))

394:     design <- model.matrix(~controlPCs)

402:     stopifnot(is.matrix(quantiles))

403:     stopifnot(is.matrix(controlMatrix))

446: ### Normalize a matrix of intensities

448:     ## normMatrix <- matrix(NA, nrow(intMatrix), ncol(intMatrix))

465:         result <- preprocessCore::normalize.quantiles.use.target(matrix(crtColumn.reduced), target)

482:         stop("'", FUN, "()' only supports matrix-backed minfi objects.",

490:     all(vapply(assays(object), is.matrix, logical(1L)))

41: #' microarray data avoiding sex bias, Wang et al., 2021.

384: .returnFit <- function(controlMatrix, quantiles, nPCs) {

387:     stopifnot(ncol(quantiles) == nrow(controlMatrix))

393:     controlPCs <- prcomp(controlMatrix)$x[,1:nPCs,drop=FALSE]

401: .returnFitBySex <- function(controlMatrix, quantiles, nPCs, sex) {

404:     stopifnot(ncol(quantiles) == nrow(controlMatrix))

419:         newQuantiles <- .returnFit(controlMatrix = controlMatrix,

426:         newQuantiles1 <- .returnFit(controlMatrix = controlMatrix1,

433:         newQuantiles2 <- .returnFit(controlMatrix = controlMatrix2,

451:         crtColumn <- intMatrix[ , i]

468:     return(normMatrix)

50:     .isMatrixBackedOrStop(rgSet, "adjustedFunnorm")

481:     if (!.isMatrixBacked(object)) {

3: for(var e in n)t.push({key:e,value:n[e]});return t},mo.merge=function(n){return Array...(5870 bytes skipped)...his)})},Ro.data=function(n,t){function e(n,e){var r,i,o,a=n.length,f=e.length,h=Math.min(a,f),g=new Array(f),p=new Array(f),d=new Array...(448 bytes skipped)...parentNode,c.push(p),l.push(g),s.push(d)}var r,i,o=-1,a=this.length;if(!arguments.length){for(n=new Array...(14084 bytes skipped)... h=[];r!==i&&r!==o;)h.push(r),r=e();(!t||(h=t(h,f++)))&&a.push(h)}return a},e.format=function(t){if(Array.isArray...(1890 bytes skipped)...v?"":xa+n.substring(v+1);!o&&c&&(m=Aa(m));var M=i.length+m.length+y.length+(p?0:t.length),x=a>M?new Array(M=a-M+1).join(e):"";return p&&(m=Aa(x+m)),t+=i,n=m+y,("<"===r?t+n+x:">"===r?x+t+n:"^"===r?x.substri...(9172 bytes skipped)...

2: ...(24707 bytes skipped)...erCase(),e);return t}function Pi(n,t,e){var r=0>n?"-":"",u=(r?-n:n)+"",i=u.length;return r+(e>i?new Array...(3999 bytes skipped)...ement,_o=window;try{Mo(bo.childNodes)[0].nodeType}catch(wo){Mo=function(n){for(var t=n.length,e=new Array...(2455 bytes skipped)...th.random()*r--,t=n[r],n[r]=n[e],n[e]=t;return n},mo.permute=function(n,t){for(var e=t.length,r=new Array(e);e--;)r[e]=n[t[e]];return r},mo.pairs=function(n){for(var t,e=0,r=n.length-1,u=n[0],i=new Array...(38 bytes skipped)...urn i},mo.zip=function(){if(!(u=arguments.length))return[];for(var n=-1,e=mo.min(arguments,t),r=new Array(e);++n<e;)for(var u,i=-1,o=r[n]=new Array(u);++i<u;)o[i]=arguments[i][n];return r},mo.transpose=function(n){return mo.zip.apply(mo,n)},mo.key...(159 bytes skipped)...

4: ...(5479 bytes skipped)...a=n.map(function(){return[]}),c=pt(e),l=pt(r),s=n.length,f=1e6;if(c===Ze&&l===Ve)t=n;else for(t=new Array...(1544 bytes skipped)...,o=n.map(function(){return[]}),a=[],c=pt(e),l=pt(r),s=n.length;if(c===Ze&&l===Ve)t=n;else for(t=new Array...(184 bytes skipped)...t:n[r]}))}),a},t.triangles=function(n){if(e===Ze&&r===Ve)return mo.geom.delaunay(n);for(var t,u=new Array...(1922 bytes skipped)...of t;return("string"===e?ga.has(t)||/^(#|rgb\(|hsl\()/.test(t)?br:Sr:t instanceof Z?br:"object"===e?Array.isArray(t)?kr:_r:wr)(n,t)}],mo.interpolateArray...(380 bytes skipped)...string(0,t):n,r=t>=0?n.substring(t+1):"in";return e=xc.get(e)||Mc,r=bc.get(r)||dt,Ar(r(e.apply(null,Array...(229 bytes skipped)...if(null!=n){t.setAttribute("transform",n);var e=t.transform.baseVal.consolidate()}return new Zr(e?e.matrix...(1063 bytes skipped)...ce.value+n.target.value)/2,(t.source.value+t.target.value)/2)})}var e,r,u,i,o,a,c,l={},s=0;return l.matrix=function(n){return arguments.length?(i=(u=n)&&u.length,e=r=null,l):u},l.padding=function(n){return ...(20385 bytes skipped)...

1: ...(4945 bytes skipped)...M();$o=!(u.f||u.e),e.remove()}return $o?(r.x=t.pageX,r.y=t.pageY):(r.x=t.clientX,r.y=t.clientY),r=r.matrixTransform(n.getScreenCTM().inverse()),[r.x,r.y]}var i=n.getBoundingClientRect();return[t.clientX-i.l...(26868 bytes skipped)...

984:   matrix <- Matrix::Matrix(0, nrow = nrow(motifs), ncol = ncol(motifs) - 21 ,sparse = TRUE)

409: makeSummarizedExperimentFromGeneMatrix <- function(exp, genome = genome){

482:   arrayType <- match.arg(plat)

555: splitmatrix <- function(x,by="row") {

981: getMatrix <- function(filename) {

6: #' a matrix or path of rda file only containing the data.

8: #' a matrix or path of rda file only containing the data. Rownames should be 

13: #'  of the gene expression and DNA methylation matrix. This should be used if your matrix

16: ...(14 bytes skipped)...A methylation" and "Gene expression"), primary (sample ID) and colname (names of the columns of the matrix).

111: #'    #1) Get gene expression matrix

282:         stop("Please the gene expression matrix should receive ENSEMBLE IDs")

346:         stop("Error DNA methylation matrix and gene expression matrix are not in the same order")

364: ...(63 bytes skipped)...ary (sample ID) and colname(DNA methylation and gene expression sample [same as the colnames of the matrix])")

383:         stop("Error DNA methylation matrix and gene expression matrix are not in the same order")

435:     stop("Please the gene expression matrix should receive ENSEMBLE IDs (ENSG)")

457:   assay <- data.matrix(met)

474: #' @title Get DNA methylation array metadata from SesameData

521: #' This function will receive the DNA methylation and gene expression matrix and will create

523: #' @param met DNA methylation matrix or Summarized Experiment

524: #' @param exp Gene expression matrix or Summarized Experiment

552: # @param x A matrix 

554: # @return A list each of which is the value of each row/column in the matrix.

772: #' @param data A MultiAssayExperiment with a DNA methylation martrix or a DNA methylation matrix

977: # This will read this homer file and create a sparce matrix

985:   colnames(matrix) <- gsub(" Distance From Peak\\(sequence,strand,conservation\\)","",colnames(motifs)[-c(1:21)])

986:   rownames(matrix) <- motifs$PeakID

987:   matrix[!is.na(motifs[,-c(1:21)])] <- 1

988:   matrix <- as(matrix, "nsparseMatrix")

989:   return(matrix)

998: #' foreground <- Matrix::Matrix(sample(0:1,size = 100,replace = TRUE), 

1002: #' background <- Matrix::Matrix(sample(0:1,size = 100,replace = TRUE), 

1016:   a <- Matrix::colSums(foreground)

1017:   b <- nrow(foreground) - Matrix::colSums(foreground)

1018:   c <- Matrix::colSums(background)

1019:   d <- nrow(background) - Matrix::colSums(background)

1021:     x <- fisher.test(matrix(c(a[i],b[i],c[i],d[i]),nrow = 2,ncol = 2))

1028:                         NumOfRegions = Matrix::colSums(foreground, na.rm=TRUE),

1165: #' @param met.platform DNA Methylation  Array platform (EPIC, 450K)

245:     exp <- makeSummarizedExperimentFromGeneMatrix(exp, genome)

488:   message("Accessing DNAm annotation from sesame package for: ", genome, " - ",arrayType)

490:     ifelse(arrayType == "450K","HM450","EPIC"),

994: #' @param foreground A nsparseMatrix object in each 1 means the motif is found in a region, 0 not.

995: #' @param background A nsparseMatrix object in each 1 means the motif is found in a region, 0 not.

5599:     chord.matrix = function(x) {

15:     d3_array = function(list) {

8:   var d3_arraySlice = [].slice, d3_array = function(list) {

5223:   function d3_interpolateArray(a, b) {

13:     d3_array(d3_documentElement.childNodes)[0].nodeType;

16:       var i = list.length, array = new Array(i);

17:       while (i--) array[i] = list[i];

18:       return array;

41:   d3.min = function(array, f) {

42:     var i = -1, n = array.length, a, b;

44:       while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;

45:       while (++i < n) if ((b = array[i]) != null && a > b) a = b;

47:       while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;

48:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;

52:   d3.max = function(array, f) {

53:     var i = -1, n = array.length, a, b;

55:       while (++i < n && !((a = array[i]) != null && a <= a)) a = undefined;

56:       while (++i < n) if ((b = array[i]) != null && b > a) a = b;

58:       while (++i < n && !((a = f.call(array, array[i], i)) != null && a <= a)) a = undefined;

59:       while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;

63:   d3.extent = function(array, f) {

64:     var i = -1, n = array.length, a, b, c;

66:       while (++i < n && !((a = c = array[i]) != null && a <= a)) a = c = undefined;

67:       while (++i < n) if ((b = array[i]) != null) {

72:       while (++i < n && !((a = c = f.call(array, array[i], i)) != null && a <= a)) a = undefined;

73:       while (++i < n) if ((b = f.call(array, array[i], i)) != null) {

80:   d3.sum = function(array, f) {

81:     var s = 0, n = array.length, a, i = -1;

83:       while (++i < n) if (!isNaN(a = +array[i])) s += a;

85:       while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;

92:   d3.mean = function(array, f) {

93:     var n = array.length, a, m = 0, i = -1, j = 0;

95:       while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j;

97:       while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j;

105:   d3.median = function(array, f) {

106:     if (arguments.length > 1) array = array.map(f);

107:     array = array.filter(d3_number);

108:     return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined;

137:   d3.shuffle = function(array) {

138:     var m = array.length, t, i;

141:       t = array[m], array[m] = array[i], array[i] = t;

143:     return array;

145:   d3.permute = function(array, indexes) {

146:     var i = indexes.length, permutes = new Array(i);

147:     while (i--) permutes[i] = array[indexes[i]];

150:   d3.pairs = function(array) {

151:     var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n);

152:     while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ];

157:     for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m; ) {

158:       for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n; ) {

167:   d3.transpose = function(matrix) {

168:     return d3.zip.apply(d3, matrix);

189:     var n = arrays.length, m, i = -1, j = 0, merged, array;

191:     merged = new Array(j);

193:       array = arrays[n];

194:       m = array.length;

196:         merged[--j] = array[m];

290:     function map(mapType, array, depth) {

291:       if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array;

292:       var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values;

294:         if (values = valuesByKey.get(keyValue = key(object = array[i]))) {

316:       var array = [], sortKey = sortKeys[depth++];

318:         array.push({

323:       return sortKey ? array.sort(function(a, b) {

325:       }) : array;

327:     nest.map = function(array, mapType) {

328:       return map(mapType, array, 0);

330:     nest.entries = function(array) {

331:       return entries(map(d3.map, array, 0), 0);

351:   d3.set = function(array) {

353:     if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]);

535:           subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j)));

749:       value = new Array(n = (group = this[0]).length);

758:       var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData;

891:     var args = d3_array(arguments);

986:     var group = d3_array(typeof nodes === "string" ? d3_selectAll(nodes, d3_document) : nodes);

1017:       var l = wrap(listener, d3_array(arguments));

1116:     return touches ? d3_array(touches).map(function(touch) {

1907:         return xhr.send.apply(xhr, [ method ].concat(d3_array(arguments)));

2012:       if (Array.isArray(rows[0])) return dsv.formatRows(rows);

2189: ...(29 bytes skipped)...gth + before.length + after.length + (zcomma ? 0 : negative.length), padding = length < width ? new Array(length = width - length + 1).join(fill) : "";

2681:   function d3_geo_clipPolygonLinkCircular(array) {

2682:     if (!(n = array.length)) return;

2683:     var n, i = 0, a = array[0], b;

2685:       a.n = b = array[i];

2689:     a.n = b = array[0];

4879:     d3_geom_voronoiCells = new Array(sites.length);

4912:       var polygons = new Array(data.length), x0 = clipExtent[0][0], y0 = clipExtent[0][1], x1 = clipExtent[1][0], y1 = clipExtent[...(6 bytes skipped)...

5220: ...(85 bytes skipped)...nterpolateRgb : d3_interpolateString : b instanceof d3_Color ? d3_interpolateRgb : t === "object" ? Array.isArray(b) ? d3_interpolateArray : d3_interpolateObject : d3_interpolateNumber)(a, b);

5377:       return new d3_transform(t ? t.matrix : d3_transformIdentity);

5527:     var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords;

5536:           x += matrix[i][j];

5550:             return sortSubgroups(matrix[i][a], matrix[i][b]);

5559:           var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k;

5600:       if (!arguments.length) return matrix;

5601:       n = (matrix = x) && matrix.length;

5808:           neighbors = new Array(n);

5889:         var i = -1, n, c = node.children = new Array(n), v = 0, j = depth + 1, d;

6190:   function d3_layout_stackMaxIndex(array) {

6191:     var i = 1, j = 0, v = array[0][1], k, n = array.length;

6193:       if ((k = array[i][1]) > v) {

8856:     return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);

9:     return d3_arraySlice.call(list);

188:   d3.merge = function(arrays) {

190:     while (++i < n) j += arrays[i].length;

1108:       point = point.matrixTransform(container.getScreenCTM().inverse());

5222:   d3.interpolateArray = d3_interpolateArray;

5272:     return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1))));

8373:             var xi = d3_interpolateArray(xExtent, extent1.x), yi = d3_interpolateArray(yExtent, extent1.y);

62:     bool matrix[MAX_UCHAR + 1][MAX_UCHAR + 1];

69:                 matrix[i][j] = (i == j);

77:                     matrix[firstTransformed][secondTransformed] = matrix[secondTransformed][firstTransformed] = true;

89:         return matrix[a][b];

353:  * NOTICE: free returned array with delete[]!

386:  * Free returned array with delete[].

482:  * Writes values of cells in block into given array, starting with first/top cell.

484:  * @param [out] dest  Array into which cell values are written. Must have size of at least WORD_SIZE.

499:  * Writes values of cells in block into given array, starting with last/bottom cell.

501:  * @param [out] dest  Array into which cell values are written. Must have size of at least WORD_SIZE.

542:  * @param [out] positions_  Array of 0-indexed positions in target at which best score was found.

543:                             Make sure to free this array with free().

544:  * @param [out] numPositions_  Number of positions in the positions_ array.

720:  * @param [in] findAlignment  If true, whole matrix is remembered and alignment data is returned.

724:  *                         Make sure to free this array using delete[].

935: ...(4 bytes skipped)...inds one possible alignment that gives optimal score by moving back through the dynamic programming matrix,

1186:     // and it could also be done for alignments - we could have one big array for alignment that would be

1249:     // Divide dynamic matrix into two halfs, left and right.

1277:     // TODO: avoid this allocation by using some shared array?

446:           Array.prototype.diff = function(a) {

903: function subsetArray(arr, indices) {

879: function subsetArrayAttrs(obj, indices) {

269:           if (Array.isArray(attr)) {

272:             } else if (Array.isArray(pt.pointNumber)) {

274:             } else if (Array.isArray(pt.pointNumbers)) {

364:     // Given an array of {curveNumber: x, pointNumber: y} objects,

394:         var key = trace._isSimpleKey ? trace.key : Array.isArray(ptNum) ? ptNum.map(function(idx) { return trace.key[idx]; }) : trace.key[ptNum];

395:         // http://stackoverflow.com/questions/10865025/merge-flatten-an-array-of-arrays-in-javascript

407:     // make sure highlight color is an array

408:     if (!Array.isArray(x.highlight.color)) {

452:         // array of "event objects" tracking the selection history

498:           // Keys are group names, values are array of selected keys from group.

582:   // key: group name, value: null or array of keys representing the

632:   if (keys !== null && !Array.isArray(keys)) {

633:     throw new Error("Invalid keys argument; null or array expected");

677:       // Get sorted array of matching indices in trace.key

825: is a 1D (or flat) array. The real difference is the meaning of haystack.

827: linked brushing on a scatterplot matrix. findSimpleMatches() returns a match iff 

886:     } else if (k === "transforms" && Array.isArray(val)) {

890:     } else if (k === "colorscale" && Array.isArray(val)) {

894:     } else if (Array.isArray(val)) {

445:           // https://stackoverflow.com/questions/1187518/how-to-get-the-difference-between-two-arrays-in-javascript

857: // find matches for a "nested" haystack (2D arrays)

895:       newObj[k] = subsetArray(val, indices);

613:           // subsetArrayAttrs doesn't mutate trace (it makes a modified clone)

614:           trace = subsetArrayAttrs(trace, matches);

684:           trace = subsetArrayAttrs(trace, matches);

769:                 frameTrace = subsetArrayAttrs(frameTrace, matches);

888:         return subsetArrayAttrs(transform, indices);

893:       newObj[k] = subsetArrayAttrs(val, indices);

113:     res <- pcaMethods::nipalsPca(Matrix = x, nPcs = ncomp, ...)

3: ##' Performs PCA on a matrix-like object where rows represent features and

10: ##' `reduced.pca` object that is a matrix with custom attributes to summarize

19: ##' * `loadings`: A matrix of variable loadings.

26: ##' @param x A matrix-like object.

64:     if (!is.matrix(x)) {

65:         x <- as.matrix(x)

70:     xt <- t(x) # transpose matrix;

131: ##' Performs t-SNE on a matrix-like object where rows represent features and

137: ##' `reduced.tsne` object that is a matrix with custom attributes to summarize

148: ##' @param x A matrix-like object.

151: ##' @param normalize A logical specifying whether the input matrix is

153: ##'   matrix is equal to unity. See [Rtsne::normalize_input] for details.

187:     if (!is.matrix(x)) {

188:         x <- as.matrix(x)

193:     xt <- t(x) # transpose matrix;

220: ##' Performs PLS-DA on a matrix-like object where rows represent features and

226: ##' so that it can be internally converted to an indicator matrix. The function

227: ##' returns a `reduced.plsda` object that is a matrix with custom attributes to

237: ##' * `coefficient`: An array of regression coefficients.

238: ##' * `loadings`: A matrix of loadings.

239: ##' * `loadings.weights`: A matrix of loading weights.

242: ##' * `Y.scores`: A matrix of Y-scores.

243: ##' * `Y.loadings`: A matrix of Y-loadings.

244: ##' * `projection`: The projection matrix.

245: ##' * `fitted.values`: An array of fitted values.

246: ##' * `residuals`: An array of regression residuals.

247: ##' * `vip`: An array of VIP (Variable Importance in the Projection)

255: ##' @param x A matrix-like object.

298:     if (!is.matrix(x)) {

299:         x <- as.matrix(x)