1. preprocessCore
  2. Commit 7a081bc10b6114af12c98e1807bcbe0614c813ff
Browse code

improved documentation

git-svn-id: file:///home/git/hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/preprocessCore@27568 bc3139a8-67e5-0310-9ffc-ced21a209358

Ben Bolstad authored on 28/09/2007 02:36:46
Showing13 changed files
DESCRIPTION
History View file @7a081bc
... ... 
@@ -1,5 +1,5 @@
1 1 
 Package: preprocessCore
2 
-Version: 0.99.21
2 
+Version: 0.99.22
3 3 
 Title: A collection of pre-processing functions
4 4 
 Author: Benjamin Milo Bolstad <bmb@bmbolstad.com>
5 5 
 Maintainer: Benjamin Milo Bolstad <bmb@bmbolstad.com>
inst/include/avg.h
History View file @7a081bc
... ... 
@@ -1,10 +1,88 @@
1 
+/*! \file avg.h
2 
+    \brief Functions for column wise summarizing a matrix by using the mean
3 
+
4 
+*/
5 
+
1 6 
 #ifndef AVG_H
2 7 
 #define AVG_H
3 8
9 
+/*! \brief Compute the mean and SE of the mean for subset of rows
10 
+ *
11 
+ *  Given a data matrix of probe intensities compute averageexpression measure and SE of this estimate
12 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the arithmetic mean
13 
+ *  is computed for each column. The sample standard error is also computed.
14 
+ *
15 
+ *
16 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
17 
+ * @param rows the number of rows in the matrix
18 
+ * @param cols the number of columns in the matrix
19 
+ * @param cur_rows indices specifying which rows in the matrix to use
20 
+ * @param results pre-allocated space to store output averages. Should be of length cols
21 
+ * @param nprobes the number of elements in cur_rows
22 
+ * @param resultsSE pre-allocated space to store SE of averages. Should be of length cols
23 
+ *
24 
+ *
25 
+ */
26 
+
4 27 
 void ColAverage(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
28 
+
29 
+/*! \brief compute the mean for specified subset of rows
30 
+ *
31 
+ *  Given a data matrix of probe intensities compute average expression measure and SE of this estimate
32 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the arithmetic mean
33 
+ *  is computed for each column. The sample standard error is also computed.
34 
+ *
35 
+ *
36 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
37 
+ * @param rows the number of rows in the matrix
38 
+ * @param cols the number of columns in the matrix
39 
+ * @param cur_rows indices specifying which rows in the matrix to use
40 
+ * @param results pre-allocated space to store output averages. Should be of length cols
41 
+ * @param nprobes the number of elements in cur_rows
42 
+ *
43 
+ *
44 
+ *
45 
+ */
46 
+
5 47 
 void ColAverage_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
6 48
49 
+/*! \brief Compute the mean and SE of the mean
50 
+ *
51 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
52 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
53 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
54 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
55 
+ *  on output the input matrix may be changed.
56 
+ *
57 
+ *
58 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
59 
+ * @param rows the number of rows in the matrix
60 
+ * @param cols the number of columns in the matrix
61 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
62 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
63 
+ *
64 
+ *
65 
+ */
66 
+
7 67 
 void colaverage_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
68 
+
69 
+/*! \brief Compute the mean and SE of the mean
70 
+ *
71 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
72 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
73 
+ *  is computed for each column. The sample standard error is also computed. On output the data matrix will
74 
+ *  be unchanged.
75 
+ *
76 
+ *
77 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
78 
+ * @param rows the number of rows in the matrix
79 
+ * @param cols the number of columns in the matrix
80 
+ * @param results pre-allocated space to store output averages. Should be of length cols
81 
+ * @param resultsSE pre-allocated space to store SE of averages. Should be of length cols
82 
+ *
83 
+ *
84 
+ */
85 
+
8 86 
 void colaverage(double *data, int rows, int cols, double *results, double *resultsSE);
9 87
10 88 
 #endif
inst/include/avg_log.h
History View file @7a081bc
... ... 
@@ -1,10 +1,90 @@
1 
+/*! \file avg_log.h
2 
+    \brief Functions for column wise summarizing a matrix by \f$log2\f$ transforming the data and then averaging
3 
+
4 
+
5 
+*/
6 
+
7 
+
1 8 
 #ifndef AVG_LOG_H
2 9 
 #define AVG_LOG_H
3 10
11 
+/*! \brief log2 transform and then compute the mean and SE of the mean for subset of rows
12 
+ *
13 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
14 
+ *  on a column by column basis using only a specified subset of rows. Specifically, each element is log2 transformed, then the arithmetic mean
15 
+ *  is computed for each column. The sample standard error is also computed.
16 
+ *
17 
+ *
18 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
19 
+ * @param rows the number of rows in the matrix
20 
+ * @param cols the number of columns in the matrix
21 
+ * @param cur_rows indices specifying which rows in the matrix to use
22 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
23 
+ * @param nprobes the number of
24 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
25 
+ *
26 
+ *
27 
+ */
28 
+
4 29 
 void AverageLog(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
30 
+
31 
+/*! \brief log2 transform and then compute the mean for subset of rows
32 
+ *
33 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
34 
+ *  on a column by column basis using only a specified subset of rows. Specifically, each element is log2 transformed, then the arithmetic mean
35 
+ *  is computed for each column. The sample standard error is also computed.
36 
+ *
37 
+ *
38 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
39 
+ * @param rows the number of rows in the matrix
40 
+ * @param cols the number of columns in the matrix
41 
+ * @param cur_rows indices specifying which rows in the matrix to use
42 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
43 
+ * @param nprobes the number of
44 
+ *
45 
+ *
46 
+ *
47 
+ */
48 
+
5 49 
 void AverageLog_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
6 50
51 
+/*! \brief log2 transform and then compute the mean and SE of the mean
52 
+ *
53 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
54 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
55 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
56 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
57 
+ *  on output the input matrix will be changed.
58 
+ *
59 
+ *
60 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
61 
+ * @param rows the number of rows in the matrix
62 
+ * @param cols the number of columns in the matrix
63 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
64 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
65 
+ *
66 
+ *
67 
+ */
68 
+
7 69 
 void averagelog_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
70 
+
71 
+/*! \brief log2 transform and then compute the mean and SE of the mean
72 
+ *
73 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
74 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
75 
+ *  is computed for each column. The sample standard error is also computed. On output the data matrix will
76 
+ *  be unchanged.
77 
+ *
78 
+ *
79 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
80 
+ * @param rows the number of rows in the matrix
81 
+ * @param cols the number of columns in the matrix
82 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
83 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
84 
+ *
85 
+ *
86 
+ */
87 
+
8 88 
 void averagelog(double *data, int rows, int cols, double *results, double *resultsSE);
9 89
10 90 
 #endif
inst/include/biweight.h
History View file @7a081bc
... ... 
@@ -1,12 +1,111 @@
1 
+/*! \file biweight.h
2 
+    \brief Functions for column wise summarizing a matrix by \f$log2\f$ transforming the data and then using a 1-step Tukey Biweight
3 
+
4 
+
5 
+*/
6 
+
1 7 
 #ifndef BIWEIGHT_H
2 8 
 #define BIWEIGHT_H 1
3 9
10 
+/*! \brief log2 transform the data and then use a 1-step Tukey Biweight to summarize each column
11 
+ *
12 
+ *  Given a data matrix of probe intensities compute average expression measure then log2 it and SE of this estimate
13 
+ *  on a column by column basis
14 
+ *
15 
+ *
16 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
17 
+ * @param rows the number of rows in the matrix
18 
+ * @param cols the number of columns in the matrix
19 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
20 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
21 
+ *
22 
+ *
23 
+ */
24 
+
4 25 
 void tukeybiweight(double *data, int rows, int cols, double *results, double *resultsSE);
26 
+
27 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
28 
+ *
29 
+ *  Given a data matrix of probe intensities compute average expression measure then log2 it and SE of this estimate
30 
+ *  on a column by column basis
31 
+ *
32 
+ *
33 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
34 
+ * @param rows the number of rows in the matrix
35 
+ * @param cols the number of columns in the matrix
36 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
37 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
38 
+ *
39 
+ *
40 
+ */
41 
+
5 42 
 void tukeybiweight_no_log(double *data, int rows, int cols, double *results, double *resultsSE);
43 
+
44 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
45 
+ *
46 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
47 
+ * corresponding to a single probeset, compute log2 transformed 1-step Tukey Biweight expression measure.
48 
+ * Note that data is a probes by chips matrix. Also compute SE estimates
49 
+ *
50 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
51 
+ * @param rows the number of rows in the matrix
52 
+ * @param cols the number of columns in the matrix
53 
+ * @param cur_rows a vector containing row indices to use
54 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
55 
+ * @param nprobes number of probes in current set
56 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
57 
+ *
58 
+ *
59 
+ */
60 
+
6 61 
 void TukeyBiweight(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
62 
+
63 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
64 
+ *
65 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
66 
+ * corresponding to a single probeset, log2 transform each data item and then compute 1-step Tukey Biweight expression measure.
67 
+ * Note that data is a probes by chips matrix.
68 
+ *
69 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
70 
+ * @param rows the number of rows in the matrix
71 
+ * @param cols the number of columns in the matrix
72 
+ * @param cur_rows a vector containing row indices to use
73 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
74 
+ * @param nprobes number of probes in current set
75 
+ *
76 
+ *
77 
+ */
78 
+
7 79 
 void TukeyBiweight_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
80 
+
81 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
82 
+ *
83 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
84 
+ * corresponding to a single probeset, compute 1-step Tukey Biweight expression measure.
85 
+ * Note that data is a probes by chips matrix.
86 
+ *
87 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
88 
+ * @param rows the number of rows in the matrix
89 
+ * @param cols the number of columns in the matrix
90 
+ * @param cur_rows a vector containing row indices to use
91 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
92 
+ * @param nprobes number of probes in current set
93 
+ *
94 
+ */
95 
+
8 96 
 void TukeyBiweight_no_log_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
9 97
98 
+/*! \brief compute a 1-step Tukey Biweight
99 
+ *
100 
+ *
101 
+ * implements one step Tukey Biweight as documented in the Affymetrix
102 
+ * Statistical Algorithms Description Document.
103 
+ *
104 
+ * @param x  vector of data
105 
+ * @param length length of vector of data
106 
+ *
107 
+ */
108 
+
10 109 
 double Tukey_Biweight(double *x, int length);
11 110
12 111 
 #endif
inst/include/lm.h
History View file @7a081bc
... ... 
@@ -1,7 +1,28 @@
1 
+/*! \file lm.h
2 
+    \brief Functions for weighted least squares regression
3 
+
4 
+*/
5 
+
1 6 
 #ifndef LM_H
2 7 
 #define LM_H
3 8
4 9
10 
+/*! \brief Weighted least squares regression
11 
+ *
12 
+ * This function computes weighted linear regression estimates using QR decomposition
13 
+ *
14 
+ *
15 
+ * @param x - Design matrix: dimension rows*cols
16 
+ * @param y - dependent variable: length rows
17 
+ * @param w - weights for each observation: length rows
18 
+ * @param rows - dimension of input
19 
+ * @param cols - dimension of input
20 
+ * @param tol - machine tolerance used in qr decomp
21 
+ * @param out_beta - place to output beta estimates: length cols
22 
+ * @param out_resids - place to output residuals: length rows
23 
+ *
24 
+ ************************************************************************/
25 
+
5 26
6 27 
 void lm_wfit(double *x, double *y, double *w, int rows, int cols, double tol, double *out_beta, double *out_resids);
7 28
inst/include/log_avg.h
History View file @7a081bc
... ... 
@@ -1,8 +1,65 @@
1 
+/*! \file log_avg.h
2 
+    \brief Functions for column wise summarizing a matrix by averaging and then \f$log2\f$ transforming the computed mean
3 
+
4 
+
5 
+*/
6 
+
1 7 
 #ifndef LOG_AVG_H
2 
-#define LOG_AVG_H 1
8 
+#define LOG_AVG_H
9 
+
10 
+/*! \brief compute the mean then log2 transform and also SE of the log2 mean
11 
+ *
12 
+ *  Given a data matrix of probe intensities compute average expression measure then log2 it and SE of this estimate
13 
+ *  on a column by column basis
14 
+ *
15 
+ *
16 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
17 
+ * @param rows the number of rows in the matrix
18 
+ * @param cols the number of columns in the matrix
19 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
20 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
21 
+ *
22 
+ *
23 
+ */
3 24
4 25 
 void logaverage(double *data, int rows, int cols, double *results, double *resultsSE);
26 
+
27 
+/*! \brief compute the average and then log2 transform it.
28 
+ *
29 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
30 
+ *      corresponding to a single probeset, compute log2 average expression measure.
31 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates
32 
+ *
33 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
34 
+ * @param rows the number of rows in the matrix
35 
+ * @param cols the number of columns in the matrix
36 
+ * @param cur_rows a vector containing row indices to use
37 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
38 
+ * @param nprobes number of probes in current set
39 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
40 
+ *
41 
+ *
42 
+ */
43 
+
5 44 
 void LogAverage(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
45 
+
46 
+
47 
+/*! \brief compute the average and then log2 transform it.
48 
+ *
49 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
50 
+ *      corresponding to a single probeset, compute log2 average expression measure.
51 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates
52 
+ *
53 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
54 
+ * @param rows the number of rows in the matrix
55 
+ * @param cols the number of columns in the matrix
56 
+ * @param cur_rows a vector containing row indices to use
57 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
58 
+ * @param nprobes number of probes in current set
59 
+ *
60 
+ *
61 
+ */
62 
+
6 63 
 void LogAverage_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
7 64
8 65 
 #endif
inst/include/log_median.h
History View file @7a081bc
... ... 
@@ -1,12 +1,88 @@
1 
+/*! \file log_median.h
2 
+    \brief Functions for column wise summarizing a matrix by computing the median and then \f$\log_2\f$ transforming
3 
+
4 
+*/
5 
+
6 
+
7 
+
1 8 
 #ifndef LOG_MEDIAN_H
2 9 
 #define LOG_MEDIAN_H 1
3 10
4 
-
11 
+/*! \brief compute the median for subset of rows and the \f$\log_2\f$ transform it
12 
+ *
13 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Also compute SE of this estimate
14 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the median of each column is computed
15 
+ *  the it is \f$\log_2\f$ transformed. The sample standard error is also computed.
16 
+ *
17 
+ *
18 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
19 
+ * @param rows the number of rows in the matrix
20 
+ * @param cols the number of columns in the matrix
21 
+ * @param cur_rows indices specifying which rows in the matrix to use
22 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
23 
+ * @param nprobes the number of
24 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
25 
+ *
26 
+ *
27 
+ */
5 28
6 29 
 void LogMedian(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
30 
+
31 
+/*! \brief compute the median for subset of rows and the \f$\log_2\f$ transform it
32 
+ *
33 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Computed on a column by column basis using only a specified subset of rows.
34 
+ * Specifically, the median of each column is computed
35 
+ *  the it is \f$\log_2\f$ transformed.
36 
+ *
37 
+ *
38 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
39 
+ * @param rows the number of rows in the matrix
40 
+ * @param cols the number of columns in the matrix
41 
+ * @param cur_rows indices specifying which rows in the matrix to use
42 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
43 
+ * @param nprobes the number of rows in cur_rows
44 
+ *
45 
+ *
46 
+ */
47 
+
7 48 
 void LogMedian_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
8 49
50 
+/*! \brief compute the median for each column and then \f$\log_2\f$ transform it
51 
+ *
52 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Also produce the SE of this estimate
53 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
54 
+ *  The sample standard error is also computed. On output the data matrix will
55 
+ *  be unchanged.
56 
+ *
57 
+ *
58 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
59 
+ * @param rows the number of rows in the matrix
60 
+ * @param cols the number of columns in the matrix
61 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
62 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
63 
+ *
64 
+ *
65 
+ */
66 
+
9 67 
 void logmedian(double *data, int rows, int cols, double *results, double *resultsSE);
68 
+
69 
+/*! \brief compute the median for each column and then \f$\log_2\f$ transform it
70 
+ *
71 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Also produce the SE of this estimate
72 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
73 
+ *  The sample standard error is also computed. On output the data matrix will
74 
+ *  be changed.
75 
+ *
76 
+ *
77 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
78 
+ * @param rows the number of rows in the matrix
79 
+ * @param cols the number of columns in the matrix
80 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
81 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
82 
+ *
83 
+ *
84 
+ */
85 
+
10 86 
 void logmedian_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
11 87
12 88 
 #endif
inst/include/median.h
History View file @7a081bc
... ... 
@@ -1,12 +1,87 @@
1 
+/*! \file median.h
2 
+    \brief Functions for column wise summarizing a matrix by using the median
3 
+
4 
+*/
5 
+
1 6 
 #ifndef MEDIAN_H
2 7 
 #define MEDIAN_H 1
3 8
4 
-
9 
+/*! \brief Compute the median and SE of the median for subset of rows
10 
+ *
11 
+ *  Given a data matrix of probe intensities compute median and SE of this estimate
12 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the arithmetic mean
13 
+ *  is computed for each column. The sample standard error is also computed.
14 
+ *
15 
+ *
16 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
17 
+ * @param rows the number of rows in the matrix
18 
+ * @param cols the number of columns in the matrix
19 
+ * @param cur_rows indices specifying which rows in the matrix to use
20 
+ * @param results pre-allocated space to store output medians. Should be of length cols
21 
+ * @param nprobes the number of elements in cur_rows
22 
+ * @param resultsSE pre-allocated space to store SE of medians. Should be of length cols
23 
+ *
24 
+ *
25 
+ */
5 26
6 27 
 void ColMedian(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
28 
+
29 
+/*! \brief compute the median for specified subset of rows
30 
+ *
31 
+ *  Given a data matrix of probe intensities compute median expression measure
32 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the median
33 
+ *  is computed for each column.
34 
+ *
35 
+ *
36 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
37 
+ * @param rows the number of rows in the matrix
38 
+ * @param cols the number of columns in the matrix
39 
+ * @param cur_rows indices specifying which rows in the matrix to use
40 
+ * @param results pre-allocated space to store output medians. Should be of length cols
41 
+ * @param nprobes the number of elements in cur_rows
42 
+ *
43 
+ *
44 
+ *
45 
+ */
46 
+
7 47 
 void ColMedian_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
8 48
49 
+/*! \brief Compute the median and SE of the median
50 
+ *
51 
+ *  Given a data matrix of probe intensities compute median measure and SE of this estimate
52 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
53 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
54 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
55 
+ *  on output the input matrix will be unchanged.
56 
+ *
57 
+ *
58 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
59 
+ * @param rows the number of rows in the matrix
60 
+ * @param cols the number of columns in the matrix
61 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
62 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
63 
+ *
64 
+ *
65 
+ */
66 
+
9 67 
 void colmedian(double *data, int rows, int cols, double *results, double *resultsSE);
68 
+
69 
+/*! \brief Compute the median and SE of the median
70 
+ *
71 
+ *  Given a data matrix of probe intensities compute median measure and SE of this estimate
72 
+ *  on a column by column basis. The sample standard error is also computed. On output the data matrix will
73 
+ *  be changed.
74 
+ *
75 
+ *
76 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
77 
+ * @param rows the number of rows in the matrix
78 
+ * @param cols the number of columns in the matrix
79 
+ * @param results pre-allocated space to store output averages. Should be of length cols
80 
+ * @param resultsSE pre-allocated space to store SE of averages. Should be of length cols
81 
+ *
82 
+ *
83 
+ */
84 
+
10 85 
 void colmedian_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
11 86
12 87
inst/include/median_log.h
History View file @7a081bc
... ... 
@@ -1,12 +1,83 @@
1 
+/*! \file median_log.h
2 
+    \brief Functions for column wise summarizing a matrix by computing the median of \f$\log_2\f$ transformed data
3 
+*/
4 
+
1 5 
 #ifndef MEDIAN_LOG_H
2 6 
 #define MEDIAN_LOG_H 1
3 7
4 
-
8 
+/*! \brief  \f$\log_2\f$ transform the data and compute the median
9 
+ *
10 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it and then compute the median. Also compute SE of this estimate
11 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the median of each column is based on
12 
+ *  \f$\log_2\f$ transformed data. The sample standard error is also computed.
13 
+ *
14 
+ *
15 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
16 
+ * @param rows the number of rows in the matrix
17 
+ * @param cols the number of columns in the matrix
18 
+ * @param cur_rows indices specifying which rows in the matrix to use
19 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
20 
+ * @param nprobes the number of rows in cur_rows
21 
+ * @param resultsSE pre-allocated space to store SE of log2 medians. Should be of length cols
22 
+ *
23 
+ *
24 
+ */
5 25
6 26 
 void MedianLog(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
27 
+
28 
+/*! \brief  \f$\log_2\f$ transform the data and compute the median
29 
+ *
30 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it and then compute the median on a column by column basis using only a specified subset of rows.
31 
+ *  Specifically, the median of each column is based on \f$\log_2\f$ transformed data.
32 
+ *
33 
+ *
34 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
35 
+ * @param rows the number of rows in the matrix
36 
+ * @param cols the number of columns in the matrix
37 
+ * @param cur_rows indices specifying which rows in the matrix to use
38 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
39 
+ * @param nprobes the number of rows in cur_rows
40 
+ *
41 
+ */
42 
+
7 43 
 void MedianLog_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes);
8 44
45 
+/*! \brief compute the median for each column of \f$\log_2\f$ transformed data.
46 
+ *
47 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it then compute median of each column. Also produce the SE of this estimate
48 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
49 
+ *  The sample standard error is also computed. On output the data matrix will
50 
+ *  be unchanged.
51 
+ *
52 
+ *
53 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
54 
+ * @param rows the number of rows in the matrix
55 
+ * @param cols the number of columns in the matrix
56 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
57 
+ * @param resultsSE pre-allocated space to store SE of log2 medians. Should be of length cols
58 
+ *
59 
+ *
60 
+ */
61 
+
9 62 
 void medianlog(double *data, int rows, int cols, double *results, double *resultsSE);
63 
+
64 
+/*! \brief compute the median for each column of \f$\log_2\f$ transformed data.
65 
+ *
66 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it then compute median of each column. Also produce the SE of this estimate
67 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
68 
+ *  The sample standard error is also computed. On output the data matrix will
69 
+ *  be changed.
70 
+ *
71 
+ *
72 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
73 
+ * @param rows the number of rows in the matrix
74 
+ * @param cols the number of columns in the matrix
75 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
76 
+ * @param resultsSE pre-allocated space to store SE of log2 medians. Should be of length cols
77 
+ *
78 
+ *
79 
+ */
80 
+
10 81 
 void medianlog_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
11 82
12 83
inst/include/medianpolish.h
History View file @7a081bc
... ... 
@@ -1,12 +1,140 @@
1 
+/*! \file medianpolish.h
2 
+    \brief Functions for column wise summarizing a matrix by using the median polish algorithm
3 
+
4 
+
5 
+*/
6 
+
1 7 
 #ifndef MEDIANPOLISH_H
2 8 
 #define MEDIANPOLISH_H 1
3 9
10 
+/*! \brief Compute medianpolish
11 
+ *
12 
+ *
13 
+ *      Given a data matrix, compute median polish parameter estimates
14 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates.
15 
+ *      The input data matrix contains the fitted residuals on output.
16 
+ *
17 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
18 
+ * @param rows the number of rows in the matrix
19 
+ * @param cols the number of columns in the matrix
20 
+ * @param r pre-allocated space to store estimated row effects. Should be of length rows. Assumed on input that this is zero-ed out.
21 
+ * @param c pre-allocated space to store estimated column effects. Should be of length cols. Assumed on input that this is zero-ed out.
22 
+ * @param t pre-allocated space to store "intercept" effect. Should be of length 1.
23 
+ *
24 
+ */
25 
+
4 26 
 void median_polish_fit_no_copy(double *data, int rows, int cols, double *r, double *c, double *t);
27 
+
28 
+/*! \brief Compute medianpolish
29 
+ *
30 
+ *
31 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
32 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates.
33 
+ *      The input data matrix contains the fitted residuals on output.
34 
+ *
35 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
36 
+ * @param rows the number of rows in the matrix
37 
+ * @param cols the number of columns in the matrix
38 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
39 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
40 
+ *
41 
+ */
42 
+
5 43 
 void median_polish_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
44 
+
45 
+/*! \brief Compute medianpolish
46 
+ *
47 
+ *
48 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
49 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates. This function
50 
+ *      \f$\log_2\f$ transforms its input before apply the median polish. The input data matrix
51 
+ *      contains the fitted residuals on output.
52 
+ *
53 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
54 
+ * @param rows the number of rows in the matrix
55 
+ * @param cols the number of columns in the matrix
56 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
57 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
58 
+ *
59 
+ */
60 
+
6 61 
 void median_polish_log2_no_copy(double *data, int rows, int cols, double *results, double *resultsSE);
62 
+
63 
+/*! \brief Compute medianpolish
64 
+ *
65 
+ *
66 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
67 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates. This function
68 
+ *      \f$\log_2\f$ transforms its input before apply the median polish.
69 
+ *
70 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
71 
+ * @param rows the number of rows in the matrix
72 
+ * @param cols the number of columns in the matrix
73 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
74 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
75 
+ * @param residuals pre-allocated space to store the redsiuals. Should be of length rows*cols
76 
+ *
77 
+ */
78 
+
7 79 
 void median_polish_log2(double *data, int rows, int cols, double *results, double *resultsSE, double *residuals);
80 
+
81 
+/*! \brief Compute medianpolish
82 
+ *
83 
+ *
84 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
85 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates.
86 
+ *
87 
+ *
88 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
89 
+ * @param rows the number of rows in the matrix
90 
+ * @param cols the number of columns in the matrix
91 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
92 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
93 
+ * @param residuals pre-allocated space to store the redsiuals. Should be of length rows*cols
94 
+ *
95 
+ */
96 
+
8 97 
 void median_polish(double *data, int rows, int cols, double *results, double *resultsSE, double *residuals);
98 
+
99 
+/*! \brief Compute medianpolish
100 
+ *
101 
+ *
102 
+ *      Given a data matrix of probe intensities, and a list of rows in the matrix
103 
+ *      corresponding to a single probeset, compute median polish expression measure.
104 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates. This function
105 
+ *      \f$\log_2\f$ transforms its inpue before apply the median polish.
106 
+ *
107 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
108 
+ * @param rows the number of rows in the matrix
109 
+ * @param cols the number of columns in the matrix
110 
+ * @param cur_rows a vector containing row indices to use
111 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
112 
+ * @param nprobes number of probes in current set
113 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
114 
+ *
115 
+ *
116 
+ */
117 
+
9 118 
 void MedianPolish(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
119 
+
120 
+/*! \brief Compute medianpolish
121 
+ *
122 
+ *
123 
+ *      Given a data matrix of probe intensities, and a list of rows in the matrix
124 
+ *      corresponding to a single probeset, compute median polish expression measure.
125 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates
126 
+ *
127 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
128 
+ * @param rows the number of rows in the matrix
129 
+ * @param cols the number of columns in the matrix
130 
+ * @param cur_rows a vector containing row indices to use
131 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
132 
+ * @param nprobes number of probes in current set
133 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
134 
+ *
135 
+ *
136 
+ */
137 
+
10 138 
 void MedianPolish_no_log(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE);
11 139
12 140
inst/include/preprocessCore_summarization_stubs.c
History View file @7a081bc
... ... 
@@ -1,7 +1,23 @@
1 1 
 #include <Rinternals.h>
2 2 
 #include <R_ext/Rdynload.h>
3 3
4 
-
4 
+/*! \brief log2 transform and then compute the mean and SE of the mean
5 
+ *
6 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
7 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
8 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
9 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
10 
+ *  on output the input matrix will be changed.
11 
+ *
12 
+ *
13 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
14 
+ * @param rows the number of rows in the matrix
15 
+ * @param cols the number of columns in the matrix
16 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
17 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
18 
+ *
19 
+ *
20 
+ */
5 21
6 22 
 void averagelog_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
7 23
... ... 
@@ -14,8 +30,6 @@ void averagelog_no_copy(double *data, int rows, int cols, double *results, doubl
14 30 
   return;
15 31 
 }
16 32
17 
-
18 
-
19 33 
 /*! \brief log2 transform and then compute the mean and SE of the mean
20 34 
  *
21 35 
  *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
... ... 
@@ -43,7 +57,6 @@ void averagelog(double *data, int rows, int cols, double *results, double *resul
43 57 
   return;
44 58 
 }
45 59
46 
-
47 60 
 /*! \brief log2 transform and then compute the mean and SE of the mean
48 61 
  *
49 62 
  * Given a data matrix of probe intensities, and a list of rows in the matrix
... ... 
@@ -72,7 +85,6 @@ void AverageLog(double *data, int rows, int cols, int *cur_rows, double *results
72 85 
   return;
73 86 
 }
74 87
75 
-
76 88 
 /*! \brief log2 transform and then compute the mean
77 89 
  *
78 90 
  *  Given a data matrix of probe intensities, and a list of rows in the matrix
... ... 
@@ -89,7 +101,6 @@ void AverageLog(double *data, int rows, int cols, int *cur_rows, double *results
89 101 
  *
90 102 
  */
91 103
92 
-
93 104 
 void AverageLog_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
94 105
95 106
... ... 
@@ -101,9 +112,6 @@ void AverageLog_noSE(double *data, int rows, int cols, int *cur_rows, double *re
101 112 
   return;
102 113 
 }
103 114
104 
-
105 
-
106 
-
107 115 
 /*! \brief compute the mean then log2 transform and also SE of the log2 mean
108 116 
  *
109 117 
  *  Given a data matrix of probe intensities compute average expression measure then log2 it and SE of this estimate
... ... 
@@ -129,8 +137,6 @@ void logaverage(double *data, int rows, int cols, double *results, double *resul
129 137 
   return;
130 138 
 }
131 139
132 
-
133 
-
134 140 
 /*! \brief compute the average and then log2 transform it.
135 141 
  *
136 142 
  * Given a data matrix of probe intensities, and a list of rows in the matrix
... ... 
@@ -159,7 +165,21 @@ void LogAverage(double *data, int rows, int cols, int *cur_rows, double *results
159 165 
   return;
160 166 
 }
161 167
162 
-
168 
+/*! \brief compute the average and then log2 transform it.
169 
+ *
170 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
171 
+ *      corresponding to a single probeset, compute log2 average expression measure.
172 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates
173 
+ *
174 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
175 
+ * @param rows the number of rows in the matrix
176 
+ * @param cols the number of columns in the matrix
177 
+ * @param cur_rows a vector containing row indices to use
178 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
179 
+ * @param nprobes number of probes in current set
180 
+ *
181 
+ *
182 
+ */
163 183
164 184 
 void LogAverage_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
165 185
... ... 
@@ -172,7 +192,20 @@ void LogAverage_noSE(double *data, int rows, int cols, int *cur_rows, double *re
172 192 
   return;
173 193 
 }
174 194
175 
-
195 
+/*! \brief log2 transform the data and then use a 1-step Tukey Biweight to summarize each column
196 
+ *
197 
+ *  Given a data matrix of probe intensities compute average expression measure then log2 it and SE of this estimate
198 
+ *  on a column by column basis
199 
+ *
200 
+ *
201 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
202 
+ * @param rows the number of rows in the matrix
203 
+ * @param cols the number of columns in the matrix
204 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
205 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
206 
+ *
207 
+ *
208 
+ */
176 209
177 210 
 void tukeybiweight(double *data, int rows, int cols, double *results, double *resultsSE){
178 211
... ... 
@@ -184,6 +217,21 @@ void tukeybiweight(double *data, int rows, int cols, double *results, double *re
184 217 
   return;
185 218 
 }
186 219
220 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
221 
+ *
222 
+ *  Given a data matrix of probe intensities compute average expression measure then log2 it and SE of this estimate
223 
+ *  on a column by column basis
224 
+ *
225 
+ *
226 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
227 
+ * @param rows the number of rows in the matrix
228 
+ * @param cols the number of columns in the matrix
229 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
230 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
231 
+ *
232 
+ *
233 
+ */
234 
+
187 235 
 void tukeybiweight_no_log(double *data, int rows, int cols, double *results, double *resultsSE){
188 236
189 237 
   static void(*fun)(double *, int, int, double *, double *) = NULL;
... ... 
@@ -194,10 +242,22 @@ void tukeybiweight_no_log(double *data, int rows, int cols, double *results, dou
194 242 
   return;
195 243 
 }
196 244
197 
-
198 
-
199 
-
200 
-
245 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
246 
+ *
247 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
248 
+ * corresponding to a single probeset, compute log2 transformed 1-step Tukey Biweight expression measure.
249 
+ * Note that data is a probes by chips matrix. Also compute SE estimates
250 
+ *
251 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
252 
+ * @param rows the number of rows in the matrix
253 
+ * @param cols the number of columns in the matrix
254 
+ * @param cur_rows a vector containing row indices to use
255 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
256 
+ * @param nprobes number of probes in current set
257 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
258 
+ *
259 
+ *
260 
+ */
201 261
202 262 
 void TukeyBiweight(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
203 263
... ... 
@@ -210,6 +270,22 @@ void TukeyBiweight(double *data, int rows, int cols, int *cur_rows, double *resu
210 270 
   return;
211 271 
 }
212 272
273 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
274 
+ *
275 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
276 
+ * corresponding to a single probeset, log2 transform each data item and then compute 1-step Tukey Biweight expression measure.
277 
+ * Note that data is a probes by chips matrix.
278 
+ *
279 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
280 
+ * @param rows the number of rows in the matrix
281 
+ * @param cols the number of columns in the matrix
282 
+ * @param cur_rows a vector containing row indices to use
283 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
284 
+ * @param nprobes number of probes in current set
285 
+ *
286 
+ *
287 
+ */
288 
+
213 289 
 void TukeyBiweight_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
214 290
215 291
... ... 
@@ -221,6 +297,20 @@ void TukeyBiweight_noSE(double *data, int rows, int cols, int *cur_rows, double
221 297 
   return;
222 298 
 }
223 299
300 
+/*! \brief Use a 1-step Tukey Biweight to summarize each column
301 
+ *
302 
+ * Given a data matrix of probe intensities, and a list of rows in the matrix
303 
+ * corresponding to a single probeset, compute 1-step Tukey Biweight expression measure.
304 
+ * Note that data is a probes by chips matrix.
305 
+ *
306 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
307 
+ * @param rows the number of rows in the matrix
308 
+ * @param cols the number of columns in the matrix
309 
+ * @param cur_rows a vector containing row indices to use
310 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
311 
+ * @param nprobes number of probes in current set
312 
+ *
313 
+ */
224 314
225 315 
 void TukeyBiweight_no_log_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
226 316
... ... 
@@ -234,8 +324,16 @@ void TukeyBiweight_no_log_noSE(double *data, int rows, int cols, int *cur_rows,
234 324 
 }
235 325
236 326
237 
-
238 
-
327 
+/*! \brief compute a 1-step Tukey Biweight
328 
+ *
329 
+ *
330 
+ * implements one step Tukey Biweight as documented in the Affymetrix
331 
+ * Statistical Algorithms Description Document.
332 
+ *
333 
+ * @param x  vector of data
334 
+ * @param length  length of vector of data
335 
+ *
336 
+ */
239 337
240 338 
 double Tukey_Biweight(double *x, int length){
241 339
... ... 
@@ -264,6 +362,21 @@ void lm_wfit(double *x, double *y, double *w, int rows, int cols, double tol, do
264 362
265 363
266 364
365 
+/*! \brief Compute medianpolish
366 
+ *
367 
+ *
368 
+ *      Given a data matrix, compute median polish parameter estimates
369 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates.
370 
+ *      The input data matrix contains the fitted residuals on output.
371 
+ *
372 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
373 
+ * @param rows the number of rows in the matrix
374 
+ * @param cols the number of columns in the matrix
375 
+ * @param r pre-allocated space to store estimated row effects. Should be of length rows. Assumed on input that this is zero-ed out.
376 
+ * @param c pre-allocated space to store estimated column effects. Should be of length cols. Assumed on input that this is zero-ed out.
377 
+ * @param t pre-allocated space to store "intercept" effect. Should be of length 1.
378 
+ *
379 
+ */
267 380
268 381 
 void median_polish_fit_no_copy(double *data, int rows, int cols, double *r, double *c, double *t){
269 382
... ... 
@@ -278,6 +391,21 @@ void median_polish_fit_no_copy(double *data, int rows, int cols, double *r, doub
278 391
279 392 
 }
280 393
394 
+/*! \brief Compute medianpolish
395 
+ *
396 
+ *
397 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
398 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates.
399 
+ *      The input data matrix contains the fitted residuals on output.
400 
+ *
401 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
402 
+ * @param rows the number of rows in the matrix
403 
+ * @param cols the number of columns in the matrix
404 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
405 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
406 
+ *
407 
+ */
408 
+
281 409 
 void median_polish_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
282 410
283 411 
   static void(*fun)(double *, int, int, double *, double *) = NULL;
... ... 
@@ -289,6 +417,22 @@ void median_polish_no_copy(double *data, int rows, int cols, double *results, do
289 417
290 418 
 }
291 419
420 
+/*! \brief Compute medianpolish
421 
+ *
422 
+ *
423 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
424 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates. This function
425 
+ *      \f$\log_2\f$ transforms its input before apply the median polish. The input data matrix
426 
+ *      contains the fitted residuals on output.
427 
+ *
428 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
429 
+ * @param rows the number of rows in the matrix
430 
+ * @param cols the number of columns in the matrix
431 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
432 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
433 
+ *
434 
+ */
435 
+
292 436 
 void median_polish_log2_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
293 437
294 438 
   static void(*fun)(double *, int, int, double *, double *) = NULL;
... ... 
@@ -300,6 +444,21 @@ void median_polish_log2_no_copy(double *data, int rows, int cols, double *result
300 444
301 445 
 }
302 446
447 
+/*! \brief Compute medianpolish
448 
+ *
449 
+ *
450 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
451 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates. This function
452 
+ *      \f$\log_2\f$ transforms its input before apply the median polish.
453 
+ *
454 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
455 
+ * @param rows the number of rows in the matrix
456 
+ * @param cols the number of columns in the matrix
457 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
458 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
459 
+ * @param residuals pre-allocated space to store the redsiuals. Should be of length rows*cols
460 
+ *
461 
+ */
303 462
304 463 
 void median_polish_log2(double *data, int rows, int cols, double *results, double *resultsSE, double *residuals){
305 464
... ... 
@@ -313,6 +472,22 @@ void median_polish_log2(double *data, int rows, int cols, double *results, doubl
313 472
314 473 
 }
315 474
475 
+/*! \brief Compute medianpolish
476 
+ *
477 
+ *
478 
+ *      Given a data matrix of probe intensities, compute median polish expression measure.
479 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates.
480 
+ *
481 
+ *
482 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
483 
+ * @param rows the number of rows in the matrix
484 
+ * @param cols the number of columns in the matrix
485 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
486 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
487 
+ * @param residuals pre-allocated space to store the redsiuals. Should be of length rows*cols
488 
+ *
489 
+ */
490 
+
316 491 
 void median_polish(double *data, int rows, int cols, double *results, double *resultsSE, double *residuals){
317 492
318 493 
   static void(*fun)(double *, int, int, double *, double *, double *) = NULL;
... ... 
@@ -324,13 +499,13 @@ void median_polish(double *data, int rows, int cols, double *results, double *re
324 499 
   return;
325 500 
 }
326 501
327 
-
328 502 
 /*! \brief Compute medianpolish
329 503 
  *
330 504 
  *
331 505 
  *      Given a data matrix of probe intensities, and a list of rows in the matrix
332 506 
  *      corresponding to a single probeset, compute median polish expression measure.
333 
- *      Note that data is a probes by chips matrix. Also compute SE estimates
507 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates. This function
508 
+ *      \f$\log_2\f$ transforms its inpue before apply the median polish.
334 509 
  *
335 510 
  * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
336 511 
  * @param rows the number of rows in the matrix
... ... 
@@ -343,6 +518,7 @@ void median_polish(double *data, int rows, int cols, double *results, double *re
343 518 
  *
344 519 
  */
345 520
521 
+
346 522 
 void MedianPolish(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
347 523
348 524
... ... 
@@ -356,6 +532,23 @@ void MedianPolish(double *data, int rows, int cols, int *cur_rows, double *resul
356 532
357 533 
 }
358 534
535 
+/*! \brief Compute medianpolish
536 
+ *
537 
+ *
538 
+ *      Given a data matrix of probe intensities, and a list of rows in the matrix
539 
+ *      corresponding to a single probeset, compute median polish expression measure.
540 
+ *      Note that data is a probes by chips matrix. Also compute SE estimates
541 
+ *
542 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
543 
+ * @param rows the number of rows in the matrix
544 
+ * @param cols the number of columns in the matrix
545 
+ * @param cur_rows a vector containing row indices to use
546 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
547 
+ * @param nprobes number of probes in current set
548 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols. Note that this is just NA values
549 
+ *
550 
+ *
551 
+ */
359 552
360 553 
 void MedianPolish_no_log(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
361 554
... ... 
@@ -477,9 +670,23 @@ void rlm_compute_se_anova(double *Y, int y_rows,int y_cols, double *beta, double
477 670
478 671 
 }
479 672
480 
-
481 
-
482 
-
673 
+/*! \brief  \f$\log_2\f$ transform the data and compute the median
674 
+ *
675 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it and then compute the median. Also compute SE of this estimate
676 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the median of each column is based on
677 
+ *  \f$\log_2\f$ transformed data. The sample standard error is also computed.
678 
+ *
679 
+ *
680 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
681 
+ * @param rows the number of rows in the matrix
682 
+ * @param cols the number of columns in the matrix
683 
+ * @param cur_rows indices specifying which rows in the matrix to use
684 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
685 
+ * @param nprobes the number of rows in cur_rows
686 
+ * @param resultsSE pre-allocated space to store SE of log2 medians. Should be of length cols
687 
+ *
688 
+ *
689 
+ */
483 690
484 691 
 void MedianLog(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
485 692
... ... 
@@ -492,6 +699,20 @@ void MedianLog(double *data, int rows, int cols, int *cur_rows, double *results,
492 699
493 700 
 }
494 701
702 
+/*! \brief  \f$\log_2\f$ transform the data and compute the median
703 
+ *
704 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it and then compute the median on a column by column basis using only a specified subset of rows.
705 
+ *  Specifically, the median of each column is based on \f$\log_2\f$ transformed data.
706 
+ *
707 
+ *
708 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
709 
+ * @param rows the number of rows in the matrix
710 
+ * @param cols the number of columns in the matrix
711 
+ * @param cur_rows indices specifying which rows in the matrix to use
712 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
713 
+ * @param nprobes the number of rows in cur_rows
714 
+ *
715 
+ */
495 716
496 717 
 void MedianLog_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
497 718
... ... 
@@ -504,6 +725,23 @@ void MedianLog_noSE(double *data, int rows, int cols, int *cur_rows, double *res
504 725
505 726 
 }
506 727
728 
+/*! \brief compute the median for each column of \f$\log_2\f$ transformed data.
729 
+ *
730 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it then compute median of each column. Also produce the SE of this estimate
731 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
732 
+ *  The sample standard error is also computed. On output the data matrix will
733 
+ *  be unchanged.
734 
+ *
735 
+ *
736 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
737 
+ * @param rows the number of rows in the matrix
738 
+ * @param cols the number of columns in the matrix
739 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
740 
+ * @param resultsSE pre-allocated space to store SE of log2 medians. Should be of length cols
741 
+ *
742 
+ *
743 
+ */
744 
+
507 745
508 746
509 747 
 void medianlog(double *data, int rows, int cols, double *results, double *resultsSE){
... ... 
@@ -517,6 +755,22 @@ void medianlog(double *data, int rows, int cols, double *results, double *result
517 755
518 756 
 }
519 757
758 
+/*! \brief compute the median for each column of \f$\log_2\f$ transformed data.
759 
+ *
760 
+ *  Given a data matrix of probe intensities \f$\log_2\f$ transform it then compute median of each column. Also produce the SE of this estimate
761 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
762 
+ *  The sample standard error is also computed. On output the data matrix will
763 
+ *  be changed.
764 
+ *
765 
+ *
766 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
767 
+ * @param rows the number of rows in the matrix
768 
+ * @param cols the number of columns in the matrix
769 
+ * @param results pre-allocated space to store output log2 medians. Should be of length cols
770 
+ * @param resultsSE pre-allocated space to store SE of log2 medians. Should be of length cols
771 
+ *
772 
+ *
773 
+ */
520 774
521 775 
 void medianlog_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
522 776
... ... 
@@ -529,7 +783,23 @@ void medianlog_no_copy(double *data, int rows, int cols, double *results, double
529 783
530 784 
 }
531 785
532 
-
786 
+/*! \brief compute the median for subset of rows and the \f$\log_2\f$ transform it
787 
+ *
788 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Also compute SE of this estimate
789 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the median of each column is computed
790 
+ *  the it is \f$\log_2\f$ transformed. The sample standard error is also computed.
791 
+ *
792 
+ *
793 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
794 
+ * @param rows the number of rows in the matrix
795 
+ * @param cols the number of columns in the matrix
796 
+ * @param cur_rows indices specifying which rows in the matrix to use
797 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
798 
+ * @param nprobes the number of rows in cur_rows
799 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
800 
+ *
801 
+ *
802 
+ */
533 803
534 804 
 void LogMedian(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
535 805
... ... 
@@ -542,6 +812,24 @@ void LogMedian(double *data, int rows, int cols, int *cur_rows, double *results,
542 812
543 813 
 }
544 814
815 
+/*! \brief compute the median for subset of rows and the \f$\log_2\f$ transform it
816 
+ *
817 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Computed on a column by column basis using only a specified subset of rows.
818 
+ * Specifically, the median of each column is computed
819 
+ *  the it is \f$\log_2\f$ transformed.
820 
+ *
821 
+ *
822 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
823 
+ * @param rows the number of rows in the matrix
824 
+ * @param cols the number of columns in the matrix
825 
+ * @param cur_rows indices specifying which rows in the matrix to use
826 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
827 
+ * @param nprobes the number of rows in cur_rows
828 
+ *
829 
+ *
830 
+ */
831 
+
832 
+
545 833 
 void LogMedian_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
546 834
547 835 
   static void(*fun)(double *, int, int, int *, double *, int, double *) = NULL;
... ... 
@@ -553,6 +841,22 @@ void LogMedian_noSE(double *data, int rows, int cols, int *cur_rows, double *res
553 841
554 842 
 }
555 843
844 
+/*! \brief compute the median for each column and then \f$\log_2\f$ transform it
845 
+ *
846 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Also produce the SE of this estimate
847 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
848 
+ *  The sample standard error is also computed. On output the data matrix will
849 
+ *  be unchanged.
850 
+ *
851 
+ *
852 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
853 
+ * @param rows the number of rows in the matrix
854 
+ * @param cols the number of columns in the matrix
855 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
856 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
857 
+ *
858 
+ *
859 
+ */
556 860
557 861 
 void logmedian(double *data, int rows, int cols, double *results, double *resultsSE){
558 862
... ... 
@@ -565,6 +869,22 @@ void logmedian(double *data, int rows, int cols, double *results, double *result
565 869
566 870 
 }
567 871
872 
+/*! \brief compute the median for each column and then \f$\log_2\f$ transform it
873 
+ *
874 
+ *  Given a data matrix of probe intensities compute median and then \f$\log_2\f$ transform it. Also produce the SE of this estimate
875 
+ *  on a column by column basis. Specifically, the median is computed for each column and then \f$\log_2\f$ transformed.
876 
+ *  The sample standard error is also computed. On output the data matrix will
877 
+ *  be changed.
878 
+ *
879 
+ *
880 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
881 
+ * @param rows the number of rows in the matrix
882 
+ * @param cols the number of columns in the matrix
883 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
884 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
885 
+ *
886 
+ *
887 
+ */
568 888
569 889 
 void logmedian_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
570 890
... ... 
@@ -578,10 +898,23 @@ void logmedian_no_copy(double *data, int rows, int cols, double *results, double
578 898 
 }
579 899
580 900
581 
-
582 
-
583 
-
584 
-
901 
+/*! \brief Compute the mean and SE of the mean
902 
+ *
903 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
904 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
905 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
906 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
907 
+ *  on output the input matrix may be changed.
908 
+ *
909 
+ *
910 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
911 
+ * @param rows the number of rows in the matrix
912 
+ * @param cols the number of columns in the matrix
913 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
914 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
915 
+ *
916 
+ *
917 
+ */
585 918
586 919 
 void colaverage_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
587 920
... ... 
@@ -594,6 +927,24 @@ void colaverage_no_copy(double *data, int rows, int cols, double *results, doubl
594 927 
   return;
595 928 
 }
596 929
930 
+/*! \brief Compute the mean and SE of the mean
931 
+ *
932 
+ *  Given a data matrix of probe intensities compute average log2 expression measure and SE of this estimate
933 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
934 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
935 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
936 
+ *  on output the input matrix may be changed.
937 
+ *
938 
+ *
939 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
940 
+ * @param rows the number of rows in the matrix
941 
+ * @param cols the number of columns in the matrix
942 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
943 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
944 
+ *
945 
+ *
946 
+ */
947 
+
597 948 
 void colaverage(double *data, int rows, int cols, double *results, double *resultsSE){
598 949
599 950 
   static void(*fun)(double*, int, int, double *, double *) = NULL;
... ... 
@@ -606,6 +957,23 @@ void colaverage(double *data, int rows, int cols, double *results, double *resul
606 957 
 }
607 958
608 959
960 
+/*! \brief Compute the mean and SE of the mean for subset of rows
961 
+ *
962 
+ *  Given a data matrix of probe intensities compute averageexpression measure and SE of this estimate
963 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the arithmetic mean
964 
+ *  is computed for each column. The sample standard error is also computed.
965 
+ *
966 
+ *
967 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
968 
+ * @param rows the number of rows in the matrix
969 
+ * @param cols the number of columns in the matrix
970 
+ * @param cur_rows indices specifying which rows in the matrix to use
971 
+ * @param results pre-allocated space to store output averages. Should be of length cols
972 
+ * @param nprobes the number of elements in cur_rows
973 
+ * @param resultsSE pre-allocated space to store SE of averages. Should be of length cols
974 
+ *
975 
+ *
976 
+ */
609 977
610 978 
 void ColAverage(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
611 979
... ... 
@@ -618,6 +986,24 @@ void ColAverage(double *data, int rows, int cols, int *cur_rows, double *results
618 986 
   return;
619 987 
 }
620 988
989 
+/*! \brief compute the mean for specified subset of rows
990 
+ *
991 
+ *  Given a data matrix of probe intensities compute average expression measure and SE of this estimate
992 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the arithmetic mean
993 
+ *  is computed for each column. The sample standard error is also computed.
994 
+ *
995 
+ *
996 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
997 
+ * @param rows the number of rows in the matrix
998 
+ * @param cols the number of columns in the matrix
999 
+ * @param cur_rows indices specifying which rows in the matrix to use
1000 
+ * @param results pre-allocated space to store output averages. Should be of length cols
1001 
+ * @param nprobes the number of elements in cur_rows
1002 
+ *
1003 
+ *
1004 
+ *
1005 
+ */
1006 
+
621 1007 
 void ColAverage_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
622 1008
623 1009 
   static void(*fun)(double*, int, int, int*, double *, int) = NULL;
... ... 
@@ -629,8 +1015,21 @@ void ColAverage_noSE(double *data, int rows, int cols, int *cur_rows, double *re
629 1015 
   return;
630 1016 
 }
631 1017
632 
-
633 
-
1018 
+/*! \brief Compute the median and SE of the median
1019 
+ *
1020 
+ *  Given a data matrix of probe intensities compute median measure and SE of this estimate
1021 
+ *  on a column by column basis. The sample standard error is also computed. On output the data matrix will
1022 
+ *  be changed.
1023 
+ *
1024 
+ *
1025 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
1026 
+ * @param rows the number of rows in the matrix
1027 
+ * @param cols the number of columns in the matrix
1028 
+ * @param results pre-allocated space to store output averages. Should be of length cols
1029 
+ * @param resultsSE pre-allocated space to store SE of averages. Should be of length cols
1030 
+ *
1031 
+ *
1032 
+ */
634 1033
635 1034 
 void colmedian_no_copy(double *data, int rows, int cols, double *results, double *resultsSE){
636 1035
... ... 
@@ -643,6 +1042,24 @@ void colmedian_no_copy(double *data, int rows, int cols, double *results, double
643 1042 
   return;
644 1043 
 }
645 1044
1045 
+/*! \brief Compute the median and SE of the median
1046 
+ *
1047 
+ *  Given a data matrix of probe intensities compute median measure and SE of this estimate
1048 
+ *  on a column by column basis. Specifically, each element is log2 transformed, then the arithmetic mean
1049 
+ *  is computed for each column. The sample standard error is also computed. This function guarantees that
1050 
+ *  no additional memory is temporarily allocated to copy the input data matrix. However, this means that
1051 
+ *  on output the input matrix will be unchanged.
1052 
+ *
1053 
+ *
1054 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
1055 
+ * @param rows the number of rows in the matrix
1056 
+ * @param cols the number of columns in the matrix
1057 
+ * @param results pre-allocated space to store output log2 averages. Should be of length cols
1058 
+ * @param resultsSE pre-allocated space to store SE of log2 averages. Should be of length cols
1059 
+ *
1060 
+ *
1061 
+ */
1062 
+
646 1063 
 void colmedian(double *data, int rows, int cols, double *results, double *resultsSE){
647 1064
648 1065 
   static void(*fun)(double*, int, int, double *, double *) = NULL;
... ... 
@@ -655,6 +1072,23 @@ void colmedian(double *data, int rows, int cols, double *results, double *result
655 1072 
 }
656 1073
657 1074
1075 
+/*! \brief Compute the median and SE of the median for subset of rows
1076 
+ *
1077 
+ *  Given a data matrix of probe intensities compute median and SE of this estimate
1078 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the arithmetic mean
1079 
+ *  is computed for each column. The sample standard error is also computed.
1080 
+ *
1081 
+ *
1082 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
1083 
+ * @param rows the number of rows in the matrix
1084 
+ * @param cols the number of columns in the matrix
1085 
+ * @param cur_rows indices specifying which rows in the matrix to use
1086 
+ * @param results pre-allocated space to store output medians. Should be of length cols
1087 
+ * @param nprobes the number of elements in cur_rows
1088 
+ * @param resultsSE pre-allocated space to store SE of medians. Should be of length cols
1089 
+ *
1090 
+ *
1091 
+ */
658 1092
659 1093 
 void ColMedian(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes, double *resultsSE){
660 1094
... ... 
@@ -667,6 +1101,24 @@ void ColMedian(double *data, int rows, int cols, int *cur_rows, double *results,
667 1101 
   return;
668 1102 
 }
669 1103
1104 
+/*! \brief compute the median for specified subset of rows
1105 
+ *
1106 
+ *  Given a data matrix of probe intensities compute median expression measure
1107 
+ *  on a column by column basis using only a specified subset of rows. Specifically, the median
1108 
+ *  is computed for each column.
1109 
+ *
1110 
+ *
1111 
+ * @param data a matrix containing data stored column-wise stored in rows*cols length of memory
1112 
+ * @param rows the number of rows in the matrix
1113 
+ * @param cols the number of columns in the matrix
1114 
+ * @param cur_rows indices specifying which rows in the matrix to use
1115 
+ * @param results pre-allocated space to store output medians. Should be of length cols
1116 
+ * @param nprobes the number of elements in cur_rows
1117 
+ *
1118 
+ *
1119 
+ *
1120 
+ */
1121 
+
670 1122 
 void ColMedian_noSE(double *data, int rows, int cols, int *cur_rows, double *results, int nprobes){
671 1123
672 1124 
   static void(*fun)(double*, int, int, int*, double *, int) = NULL;
inst/include/rlm.h
History View file @7a081bc
... ... 
@@ -1,17 +1,92 @@
1 
+/*! \file rlm.h
2 
+    \brief Functions for fitting robust linear models
3 
+
4 
+*/
5 
+
6 
+
1 7 
 #ifndef RLM_H
2 8 
 #define RLM_H 1
3 9
10 
+/*! \brief robust linear regression fit using iteratively reweighted least squares
11 
+ *
12 
+ *
13 
+ * @param x  Design matrix: dimension rows*cols
14 
+ * @param y  dependent variable: length rows
15 
+ * @param rows  dimension of input
16 
+ * @param cols  dimension of input
17 
+ * @param out_beta  place to output beta estimates: length cols
18 
+ * @param out_resids  place to output residuals: length rows
19 
+ * @param out_weights  place to output weights: length rows
20 
+ * @param PsiFn  a function used to determine weights based on standardized residuals
21 
+ * @param psi_k  a tuning parameter for the PsiFn
22 
+ * @param max_iter  maximum number of iterations (if don't converge before)
23 
+ * @param initialized  do we have initial estimates of beta
24 
+ *
25 
+ */
26 
+
4 27 
 void rlm_fit(double *x, double *y, int rows, int cols, double *out_beta, double *out_resids, double *out_weights, double (* PsiFn)(double, double, int), double psi_k, int max_iter,int initialized);
28 
+/*! \brief robust linear regression fit using iteratively reweighted least squares
29 
+ *
30 
+ *
31 
+ * @param x  Design matrix: dimension rows*cols
32 
+ * @param y  dependent variable: length rows
33 
+ * @param w  weights for each observation: length rows
34 
+ * @param rows  dimension of input
35 
+ * @param cols  dimension of input
36 
+ * @param out_beta  place to output beta estimates: length cols
37 
+ * @param out_resids  place to output residuals: length rows
38 
+ * @param out_weights  place to output weights: length rows
39 
+ * @param PsiFn  a function used to determine weights based on standardized residuals
40 
+ * @param psi_k  a tuning parameter for the PsiFn
41 
+ * @param max_iter  maximum number of iterations (if don't converge before)
42 
+ * @param initialized  do we have initial estimates of beta
43 
+ *
44 
+ */
5 45
6 46 
 void rlm_wfit(double *x, double *y, double *w, int rows, int cols, double *out_beta, double *out_resids, double *out_weights, double (* PsiFn)(double, double, int), double psi_k, int max_iter,int initialized);
7 47
8 48
9 49
10 50 
 double med_abs(double *x, int length);
11 
-double irls_delta(double *old, double *new, int length);
51 
+/* double irls_delta(double *old, double *new, int length); */
52 
+
53 
+/*! \brief robust linear regression fit row-colum model
54 
+ *
55 
+ * Fits the model y = cols + rows + errors with constraint sum rows = 0
56 
+ *
57 
+ * @param y  dependent variable: length y_rows*y_cols
58 
+ * @param y_rows  dimension of input
59 
+ * @param y_cols  dimension of input
60 
+ * @param out_beta  place to output beta estimates: length (y_rows + y_cols -1)
61 
+ * @param out_resids  place to output residuals: length y_rows*y_cols
62 
+ * @param out_weights  place to output weights: length y_rows*y_cols
63 
+ * @param PsiFn  a function used to determine weights based on standardized residuals
64 
+ * @param psi_k  a tuning parameter for the PsiFn
65 
+ * @param max_iter  maximum number of iterations (if don't converge before)
66 
+ * @param initialized  do we have initial estimates of beta
67 
+ *
68 
+ */
12 69
13 70 
 void rlm_fit_anova(double *y, int y_rows, int y_cols,double *out_beta, double *out_resids, double *out_weights,double (* PsiFn)(double, double, int), double psi_k,int max_iter, int initialized);
14 71
72 
+/*! \brief robust linear regression fit row-colum model
73 
+ *
74 
+ * Fits the model y = cols + rows + errors with constraint sum rows = 0
75 
+ *
76 
+ * @param y  dependent variable: length y_rows*y_cols
77 
+ * @param y_rows  dimension of input
78 
+ * @param y_cols  dimension of input
79 
+ * @param w  weights for each observation: length y_rows*y_cols
80 
+ * @param out_beta  place to output beta estimates: length (y_rows + y_cols -1)
81 
+ * @param out_resids  place to output residuals: length y_rows*y_cols
82 
+ * @param out_weights  place to output weights: length y_rows*y_cols
83 
+ * @param PsiFn  a function used to determine weights based on standardized residuals
84 
+ * @param psi_k  a tuning parameter for the PsiFn
85 
+ * @param max_iter  maximum number of iterations (if don't converge before)
86 
+ * @param initialized  do we have initial estimates of beta
87 
+ *
88 
+ */
89 
+
15 90 
 void rlm_wfit_anova(double *y, int y_rows, int y_cols, double *w, double *out_beta, double *out_resids, double *out_weights,double (* PsiFn)(double, double, int), double psi_k,int max_iter, int initialized);
16 91
17 92 
 #endif
inst/include/rlm_se.h
History View file @7a081bc
... ... 
@@ -1,8 +1,52 @@
1 
+/*! \file rlm_se.h
2 
+    \brief Functions for computing SE for fitted robust linear models
3 
+
4 
+*/
5 
+
1 6 
 #ifndef RLM_SE_H
2 7 
 #define RLM_SE_H 1
3 8
9 
+/*! \brief Estimate SE for robust linear regression fit using iteratively reweighted least squares
10 
+ *
11 
+ *
12 
+ * @param X  Design matrix: dimension n*p
13 
+ * @param Y  dependent variable: length n
14 
+ * @param n  dimension of input
15 
+ * @param p  dimension of input
16 
+ * @param beta  fitted parameter estimates: length p
17 
+ * @param resids estimated residuals: length n
18 
+ * @param weights  estimated weights: length n
19 
+ * @param se_estimates on output contains standard error estimates : length p
20 
+ * @param varcov a place to store estimated variance covariance matrix: dimension p*p (or set to NULL)
21 
+ * @param residSE estimated residual standard error
22 
+ * @param method should be integer 1,2,3 or 4 (4 is the default).
23 
+ * @param PsiFn  a function used to determine weights based on standardized residuals
24 
+ * @param psi_k  a tuning parameter for the PsiFn
25 
+ *
26 
+ */
27 
+
4 28
5 29 
 void rlm_compute_se(double *X,double *Y, int n, int p, double *beta, double *resids,double *weights,double *se_estimates,double *varcov, double *residSE, int method,double (* PsiFn)(double, double, int), double psi_k);
30 
+
31 
+/*! \brief Estimate SE for robust linear regression fit using iteratively reweighted least squares
32 
+ *
33 
+ * Specialized to the model y = cols + rows + error model
34 
+ *
35 
+ * @param Y  dependent variable: length y_rows*y_cols
36 
+ * @param y_rows  dimension of input
37 
+ * @param y_cols  dimension of input
38 
+ * @param beta  fitted parameter estimates: length y_rows + y_cols -1
39 
+ * @param resids estimated residuals: length y_rows*y_cols
40 
+ * @param weights  estimated weights: length y_rows*y_cols
41 
+ * @param se_estimates on output contains standard error estimates : y_rows + y_cols -1
42 
+ * @param varcov a place to store estimated variance covariance matrix: dimension (y_rows + y_cols -1)*(y_rows + y_cols -1) (or set to NULL)
43 
+ * @param residSE estimated residual standard error
44 
+ * @param method should be integer 1,2,3 or 4 (4 is the default).
45 
+ * @param PsiFn  a function used to determine weights based on standardized residuals
46 
+ * @param psi_k  a tuning parameter for the PsiFn
47 
+ *
48 
+ */
49 
+
6 50 
 void rlm_compute_se_anova(double *Y, int y_rows,int y_cols, double *beta, double *resids,double *weights,double *se_estimates, double *varcov, double *residSE, int method,double (* PsiFn)(double, double, int), double psi_k);
7 51
8 52 
 #endif