normalizeBetweenArrays         package:limma         R Documentation

_N_o_r_m_a_l_i_z_e _B_e_t_w_e_e_n _A_r_r_a_y_s

_D_e_s_c_r_i_p_t_i_o_n:

     Normalizes expression intensities so that the intensities or
     log-ratios have similar distributions across a series of arrays.

_U_s_a_g_e:

     normalizeBetweenArrays(object, method="Aquantile", targets=NULL, ...)

_A_r_g_u_m_e_n_t_s:

  object: a 'matrix', 'RGList' or 'MAList' object containing expression
          ratios for a series of arrays

  method: character string specifying the normalization method to be
          used. Choices are '"none"', '"scale"', '"quantile"',
          '"Aquantile"', '"Gquantile"', '"Rquantile"', '"Tquantile"' or
          '"vsn"'. A partial string sufficient to uniquely identify the
          choice is permitted.

 targets: vector, factor or matrix of length twice the number of
          arrays, used to indicate target groups if
          'method="Tquantile"'

     ...: other arguments are passed to 'normalizeQuantiles' if one of
          the quantile methods are used or to 'vsn' if 'method="vsn"'

_D_e_t_a_i_l_s:

     'normalizeWithinArrays' normalizes expression values to make
     intensities consistent within each array. 'normalizeBetweenArrays'
     normalizes expression values to achieve consistency between
     arrays. Normalization between arrays is usually, but not
     necessarily, applied after normalization within arrays. An
     exception is 'method="vsn"', see below.

     The scale normalization method was proposed by Yang et al (2001,
     2002) and is further explained by Smyth and Speed (2003). The idea
     is simply to scale the log-ratios to have the same
     median-abolute-deviation (MAD) across arrays. This idea has also
     been implemented by the 'maNormScale' function in the marrayNorm
     package. The implementation here is slightly different in that the
     MAD scale estimator is replaced with the median-absolute-value and
     the A-values are normalized as well as the M-values.

     Quantile normalization was proposed by Bolstad et al (2003) for
     Affymetrix-style single-channel arrays and by Yang and Thorne
     (2003) for two-color cDNA arrays. 'method="quantile"' ensures that
     the intensities have the same empirical distribution across arrays
     and across channels. 'method="Aquantile"' ensures that the
     A-values (average intensities) have the same empirical
     distribution across arrays leaving the M-values (log-ratios)
     unchanged. These two methods are called "q" and "Aq" respectively
     in Yang and Thorne (2003).

     'method="Tquantile"' performs quantile normalization separately
     for the groups indicated by 'targets'. 'targets' may be a target
     matrix such as read by 'readTargets' or can be a vector indicating
     green channel groups followed by red channel groups.

     'method="Gquantile"' ensures that the green (first) channel has
     the same empirical distribution across arrays, leaving the
     M-values (log-ratios) unchanged. This method might be used when
     the green channel is a common reference throughout the experiment.
     In such a case the green channel represents the same target
     throughout, so it makes compelling sense to force the distribution
     of intensities to be same for the green channel on all the arrays,
     and to adjust to the red channel accordingly. 'method="Rquantile"'
     ensures that the red (second) channel has the same empirical
     distribution across arrays, leaving the M-values (log-ratios)
     unchanged. Both 'Gquantile' and 'Rquantile' normalization have the
     implicit effect of changing the red and green log-intensities by
     equal amounts.

     If 'object' is a 'matrix' then the scale, quantile or vsn
     normalization will be applied to the columns. Applying
     'method="Aquantile"' when 'object' is a 'matrix' will produce an
     error.

     'method="vsn"' uses the 'vsn' function from the vsn package. For
     this option the input 'object' should contain raw intensities,
     i.e., prior to background correction, log-transformation or any
     normalization. Note that the normalized intensities are on the
     log-2 scale, not the log-e scale output by the 'vsn' function in
     the vsn package.

_V_a_l_u_e:

     If 'object' is a matrix then 'normalizeBetweenArrays' produces a
     matrix of the same size. Otherwise, 'normalizeBetweenArrays'
     produces an 'MAList' object with M and A-values on the log-2
     scale.

_A_u_t_h_o_r(_s):

     Gordon Smyth

_R_e_f_e_r_e_n_c_e_s:

     Bolstad, B. M., Irizarry R. A., Astrand, M., and Speed, T. P.
     (2003), A comparison of normalization methods for high density
     oligonucleotide array data based on bias and variance.
     _Bioinformatics_ *19*, 185-193.

     Smyth, G. K., and Speed, T. P. (2003). Normalization of cDNA
     microarray data. _Methods_ *31*, 265-273. 

     Yang, Y. H., Dudoit, S., Luu, P., and Speed, T. P. (2001).
     Normalization for cDNA microarray data. In _Microarrays: Optical
     Technologies and Informatics_, M. L. Bittner, Y. Chen, A. N.
     Dorsel, and E. R. Dougherty (eds), Proceedings of SPIE, Volume
     4266, pp. 141-152. 

     Yang, Y. H., Dudoit, S., Luu, P., Lin, D. M., Peng, V., Ngai, J.,
     and Speed, T. P. (2002). Normalization for cDNA microarray data: a
     robust composite method addressing single and multiple slide
     systematic variation. _Nucleic Acids Research_ *30*(4):e15.

     Yang, Y. H., and Thorne, N. P. (2003). Normalization for two-color
     cDNA microarray data. In: D. R. Goldstein (ed.), _Science and
     Statistics: A Festschrift for Terry Speed_, IMS Lecture Notes -
     Monograph Series, Volume 40, pp. 403-418.

_S_e_e _A_l_s_o:

     An overview of LIMMA functions for normalization is given in
     05.Normalization.

     See also 'maNormScale' in the marrayNorm package, 'normalize' in
     the affy package and 'vsn' in the vsn package.

_E_x_a_m_p_l_e_s:

     library(sma)
     data(MouseArray)
     MA <- normalizeWithinArrays(mouse.data, mouse.setup)
     plot.scale.box(MA$M)

     #  Between array scale normalization as in Yang et al (2001):
     MA <- normalizeBetweenArrays(MA,method="scale")
     print(MA)
     show(MA)
     plot.scale.box(MA$M)

     #  One can get the same results using the matrix method:
     M <- normalizeBetweenArrays(MA$M,method="scale")
     plot.scale.box(M)

     #  MpAq normalization as in Yang and Thorne (2003):
     MpAq <- normalizeWithinArrays(mouse.data, mouse.setup)
     MpAq <- normalizeBetweenArrays(MpAq, method="Aq")
     plotDensities(MpAq)

