BruteAggreg            package:RankAggreg            R Documentation

_W_e_i_g_h_t_e_d _R_a_n_k _A_g_g_r_e_g_a_t_i_o_n _v_i_a _b_r_u_t_e _f_o_r_c_e _a_l_g_o_r_i_t_h_m

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

     Weighted rank aggregation of ordered lists is performed using the
     brute force approach, i.e.  generating all possible ordered lists
     and finding the list with the minimum value of the objective
     function

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

     BruteAggreg(x, k, weighted = FALSE, index.weights = NULL, distance = c("Spearman", "Kendall"))

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

       x: a matrix of ordered lists to be combined (lists must be in
          rows)

       k: size of the top-k list

weighted: boolean, if weights are to be used

index.weights: scores (weights) to be used in the aggregation process

distance: distance which "measures" the similarity between the ordered
          lists

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

     The function performs rank aggregation using the old-fashion brute
     force approach. This approach works for small problems only and
     should not be attempted if k is relatively large (k > 10). To 
     generate all possible ordered lists, the permutation function from
     the gtools package is used. Both weighted and unweighted rank
     aggregation can be performed. Please refer to the documentation
     for  RankAggreg function as the same constraints on x and
     index.weights apply to both functions.

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

top.list: Top-k aggregated list

fn.score: the minimum value of the objective function corresponding to
          the top-k list

distance: distance used by the algorithm

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

     Vasyl Pihur, Somnath Datta, Susmita Datta

_R_e_f_e_r_e_n_c_e_s:

     Pihur, V., Datta, S., and Datta, S. (2007) "Weighted rank
     aggregation of cluster validation  measures: a Monte Carlo
     cross-entropy approach" Bioinformatics, 23(13):1607-1615

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

     'RankAggreg'

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

     require(gtools)

     # rank aggregation without weights
     x <- matrix(c("A", "B", "C", "D", "E",
             "B", "D", "A", "E", "C",
             "B", "A", "E", "C", "D",
             "A", "D", "B", "C", "E"), byrow=TRUE, ncol=5)

     (toplist <- BruteAggreg(x, 5))

     # weighted rank aggregation
     set.seed(100)
     w <- matrix(rnorm(20), ncol=5)
     w <- t(apply(w, 1, sort))
     (toplist <- BruteAggreg(x,5,TRUE,w)) # using the Spearman distance
     (toplist <- BruteAggreg(x,5,TRUE,w,"Kendall")) #using the Kendall distance

