invertMap             package:affxparser             R Documentation

_I_n_v_e_r_t_s _a _r_e_a_d _o_r _a _w_r_i_t_e _m_a_p

_D_e_s_c_r_i_p_t_i_o_n:

     Inverts a read or a write map.

_U_s_a_g_e:

     invertMap(map, ...)

_A_r_g_u_m_e_n_t_s:

     map: An 'integer' 'vector'.

     ...: Not used.

_D_e_t_a_i_l_s:

     An map is defined to be a 'vector' of _n_ with unique finite
     values in [1,n].  Finding the inverse of a map is the same as
     finding the rank of each element, cf. 'order'().  However, this
     method is much faster, because it utilizes the fact that all
     values are unique and in [1,n].  Moreover, for any map it holds
     that taking the inverse twice will result in the same map.

_V_a_l_u_e:

     Returns an 'integer' 'vector'.

_A_u_t_h_o_r(_s):

     Henrik Bengtsson (<URL: http://www.braju.com/R/>)

_S_e_e _A_l_s_o:

     To generate an optimized write map for a CDF file, see
     'readCdfUnitsWriteMap'().

_E_x_a_m_p_l_e_s:

     # Simulate a read map for a chip with 2.6 million cells
     nbrOfCells <- 2600000
     readMap <- sample(nbrOfCells)

     # Get the corresponding write map
     writeMap <- invertMap(readMap)

     # A map inverted twice should be equal itself
     stopifnot(identical(invertMap(writeMap), readMap))

     # Another example illustrating that the write map is the
     # inverse of the read map
     idx <- sample(nbrOfCells, size=1000)
     stopifnot(identical(writeMap[readMap[idx]], idx))

     # invertMap() is much faster than order()
     t1 <- system.time(invertMap(readMap))[3]
     cat(sprintf("invertMap()  : %5.2fs [ 1.00x]\n", t1))

     t2 <- system.time(writeMap2 <- sort.list(readMap, na.last=NA, method="quick"))[3]
     cat(sprintf("'quick sort' : %5.2fs [%5.2fx]\n", t2, t2/t1))
     stopifnot(identical(writeMap, writeMap2))

     t3 <- system.time(writeMap2 <- order(readMap))[3]
     cat(sprintf("order()      : %5.2fs [%5.2fx]\n", t3, t3/t1))
     stopifnot(identical(writeMap, writeMap2))

     # Clean up
     rm(nbrOfCells, idx, readMap, writeMap, writeMap2)

