suppfun.RdFunction suppfun() is an S3 generic that returns a support
function, dispatching on the class of its primary argument.
# S3 method for class 'ordertable'
suppfun(x, ...)
# S3 method for class 'ranktable'
suppfun(x, times, ...)
# S3 method for class 'character'
suppfun(x, nonfinishers, ...)
suppfun(x, ...)Dataset to be converted to a support function
Vector corresponding to rows of x giving how many
times that observation was obtained (cf preflib datasets);
recycled if necessary
Character vector of competitors who did not
finish, passed to rankvec_likelihood()
Further arguments
Function suppfun() is intended as a consistent S3 generic
approach to converting datasets to support functions. I am gradually
going to switch out use of ordertable2supp() in favour of
suppfun() in the docs.
If given a data frame, suppfun() will not guess whether it is to
be interpreted as an ordertable or a ranktable, and return an error.
Generally, return a support function
suppfun(pentathlon_table)
#> log(Capalini^5 * (Capalini + Cerkovskis + Meliakh + Michalik + Moiseev
#> + Walther)^-1 * (Capalini + Cerkovskis + Meliakh + Michalik + Moiseev +
#> Walther + Zadneprovskis)^-5 * (Capalini + Cerkovskis + Meliakh +
#> Michalik + Walther)^-1 * (Capalini + Cerkovskis + Meliakh + Michalik +
#> Walther + Zadneprovskis)^-2 * (Capalini + Cerkovskis + Michalik +
#> Moiseev + Walther + Zadneprovskis)^-2 * (Capalini + Cerkovskis +
#> Moiseev + Walther + Zadneprovskis)^-2 * (Capalini + Meliakh)^-1 *
#> (Capalini + Meliakh + Michalik + Moiseev)^-1 * (Capalini + Meliakh +
#> Michalik + Moiseev + Walther)^-1 * (Capalini + Meliakh + Michalik +
#> Walther)^-1 * (Capalini + Meliakh + Walther)^-1 * (Capalini + Moiseev +
#> Walther + Zadneprovskis)^-1 * Cerkovskis^3 * (Cerkovskis + Meliakh +
#> Michalik + Walther + Zadneprovskis)^-1 * (Cerkovskis + Meliakh +
#> Michalik + Zadneprovskis)^-1 * (Cerkovskis + Michalik)^-1 * (Cerkovskis
#> + Michalik + Zadneprovskis)^-1 * (Cerkovskis + Moiseev)^-1 *
#> (Cerkovskis + Moiseev + Walther + Zadneprovskis)^-1 * (Cerkovskis +
#> Moiseev + Zadneprovskis)^-1 * Meliakh^4 * (Meliakh + Michalik)^-1 *
#> (Meliakh + Michalik + Moiseev)^-1 * Michalik^4 * Moiseev^5 * (Moiseev +
#> Walther + Zadneprovskis)^-1 * Walther^4 * (Walther + Zadneprovskis)^-1
#> * Zadneprovskis^5)
suppfun(rrank(10, p = (7:1)/28))
#> log(a^10 * (a + b + c + d + e + f)^-2 * (a + b + c + d + e + f + g)^-10
#> * (a + b + c + d + e + g)^-1 * (a + b + c + d + f)^-1 * (a + b + c + d
#> + f + g)^-1 * (a + b + c + f + g)^-1 * (a + b + d + e + f)^-1 * (a + b
#> + d + e + f + g)^-1 * (a + b + d + e + g)^-1 * (a + b + d + f + g)^-1 *
#> (a + c + d + e + f + g)^-1 * (a + c + d + f)^-1 * (a + c + f)^-1 * (a +
#> d + e + g)^-1 * (a + d + f + g)^-1 * (a + d + g)^-1 * (a + g)^-1 * b^9
#> * (b + c + d + e + f + g)^-4 * (b + c + d + e + g)^-1 * (b + c + d + f
#> + g)^-1 * (b + c + f + g)^-1 * (b + d + e + f)^-1 * (b + d + e + f +
#> g)^-2 * (b + d + e + g)^-1 * (b + d + f + g)^-1 * (b + d + g)^-1 * (b +
#> e + f + g)^-2 * (b + f + g)^-2 * (b + g)^-1 * c^10 * (c + d + e + f +
#> g)^-1 * (c + f)^-1 * d^10 * (d + e + f)^-1 * (d + e + f + g)^-1 * (d +
#> e + g)^-1 * (d + f)^-1 * e^10 * (e + f)^-1 * (e + f + g)^-3 * (e +
#> g)^-3 * f^7 * (f + g)^-2 * g^4)
suppfun(letters)
#> log( a * (a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p
#> + q + r + s + t + u + v + w + x + y + z)^-1 * b * (b + c + d + e + f +
#> g + h + i + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x +
#> y + z)^-1 * c * (c + d + e + f + g + h + i + j + k + l + m + n + o + p
#> + q + r + s + t + u + v + w + x + y + z)^-1 * d * (d + e + f + g + h +
#> i + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x + y +
#> z)^-1 * e * (e + f + g + h + i + j + k + l + m + n + o + p + q + r + s
#> + t + u + v + w + x + y + z)^-1 * f * (f + g + h + i + j + k + l + m +
#> n + o + p + q + r + s + t + u + v + w + x + y + z)^-1 * g * (g + h + i
#> + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x + y + z)^-1
#> * h * (h + i + j + k + l + m + n + o + p + q + r + s + t + u + v + w +
#> x + y + z)^-1 * i * (i + j + k + l + m + n + o + p + q + r + s + t + u
#> + v + w + x + y + z)^-1 * j * (j + k + l + m + n + o + p + q + r + s +
#> t + u + v + w + x + y + z)^-1 * k * (k + l + m + n + o + p + q + r + s
#> + t + u + v + w + x + y + z)^-1 * l * (l + m + n + o + p + q + r + s +
#> t + u + v + w + x + y + z)^-1 * m * (m + n + o + p + q + r + s + t + u
#> + v + w + x + y + z)^-1 * n * (n + o + p + q + r + s + t + u + v + w +
#> x + y + z)^-1 * o * (o + p + q + r + s + t + u + v + w + x + y + z)^-1
#> * p * (p + q + r + s + t + u + v + w + x + y + z)^-1 * q * (q + r + s +
#> t + u + v + w + x + y + z)^-1 * r * (r + s + t + u + v + w + x + y +
#> z)^-1 * s * (s + t + u + v + w + x + y + z)^-1 * t * (t + u + v + w + x
#> + y + z)^-1 * u * (u + v + w + x + y + z)^-1 * v * (v + w + x + y +
#> z)^-1 * w * (w + x + y + z)^-1 * x * (x + y + z)^-1 * y * (y + z)^-1)
suppfun(c(c = 2, b = 1, a = 3))
#> log((a + b + c)^-1 * (a + c)^-1 * b * c)