equate (version 0.1-0)

equate: Linear and Equipercentile Equating

Description

This function performs linear and equipercentile equating of test scores under the random groups and nonequivalent groups with anchor test designs (as described in Kolen & Brennan, 2004).

Usage

equate(x, y, scale, type, method = "none", bootse = FALSE,
  internal = TRUE, Ky = max(scale), xv, yv, vscale, w, ...)

Arguments

x, y

vectors of scores for forms X and Y, either as total scores (one per examinee), or total counts (one per score scale point). Total scores are required for the nonequivalent groups design

scale

the score scale as a vector

type

the type of equating, as the string "mean", "linear" (default), or "equipercentile"

method

string specifying the equating method, where "none" (default) indicates observed score equating under the random groups design, and "tucker", "levine", and "frequency" (i.e., frequency estimation) indica

bootse

logical indicating whether or not bootstrap standard errors of equating should be returned (default is FALSE)

internal

logical indicating whether or not the anchor item scores are included in the total scores (applies only to the Levine method; default is TRUE)

Ky

integer, typically indicating the number of items on form Y, or the maximum possible score on Y. This value is used in equipercentile equating for the extremes of the scale (see equate.eq for details)

xv, yv

vectors of anchor test total scores for form X and Y examinees

vscale

the score scale for the anchor test, as a vector

w

value between 0 and 1 specifying the weight applied to form X scores (and implicitly specifying the form Y weight as 1 - w)

...

further arguments passed to or from other methods

Value

• An object of class equate is returned, listing the following components (the last 7 are conditional on the equating type, method, and smoothing):
• type
  equating type
• method
  equating method
• design
  equating design, inferred from the method
• stats
  matrix of means and standard deviations for the raw scores
• freqtab
  frequency table containing the score scale, frequencies, and the cumulative distribution functions for forms X and Y
• concordance
  conversion table containing scores on X with their form Y equivalents. For the random groups design a column of standard errors is included (see se.ln and se.eq for details)
• coefficients
  slope and intercept used in mean and linear equating
• synthstats
  matrix of means and standard deviations for the anchor and synthetic distributions
• synthtab
  frequency table for the synthetic distribution, used in frequency estimation equipercentile equating
• anchortab
  frequency table for the anchor test
• smoothmethod
  smoothing method
• smoothout
  a list of smoothing output, the length of which depends on the method chosen (for loglinear smoothing this list will be very long)
• bootse
  vector of bootstrap standard errors of equating

Details

As noted above, for the random groups design x and y can be supplied as either total scores, where the length of each will equal the number of examinees, or as counts, where the length of each will equal the length of the score scale with each value indicating the total number of examinees obtaining the corresponding score. The equating design is implied by the method argument, where "none" (default) indicates that no method is needed (because examinees taking forms X and Y are assumed to be randomly equivalent). The Tucker, Levine, and frequency estimation methods are supported for the nonequivalent groups with anchor test design. For these methods only total scores may be used for x and y (one per examinee) and additional arguments are required: xv, yv, w (the weight applied to form X when calculating the synthetic distribution), and vscale. See synthetic for details. For both mean and linear equating arguments are passed to equate.ln, and subsequenty to synthetic when the Tucker or Levine method is requested. The Levine method, or more specifically the Levine observed score method, requires the additional argument internal which is used to estimate the relationship between the anchor and total scores. For equipercentile equating, arguments are passed to equate.eq, where smoothing is carried out using the functions freqbump, freqavg and loglinear, each requiring additional smoothing parameters. Standard errors are returned for the random groups design only. Bootstrap standard errors may be requested, in which case the default is 500 replications, sampling the maximum amount from each score distribution (see se.boot).

References

Kolen, M. J., & Brennan, R. L. (2004) Test Equating, Scaling, and Linking. (2nd ed.), New York: Springer.

See Also

equate, equate.ln, equate.eq, synthetic, freqbump, freqavg, loglinear, se.ln, se.eq, se.boot

Examples

#--------------------------------------------------------------
# random groups equating for (1) mean, (2) linear, 
# (3) equipercentile, and (4) equipercentile with 
# loglinear smoothing:

rx <- ACTmath[,2]
ry <- ACTmath[,3]
rscale <- ACTmath[,1]
set.seed(2007)

req1 <- equate(rx,ry,rscale,type="m",bootse=TRUE,reps=100)
req2 <- equate(rx,ry,rscale,type="l",bootse=TRUE,reps=100)
req3 <- equate(rx,ry,rscale,type="e",bootse=TRUE,reps=100)
req4 <- equate(rx,ry,rscale,type="e",bootse=TRUE,reps=100,
  smooth="loglin",degree=3)

# compare equated scores and boostrap standard errors:
cbind(rscale,mean=req1$conc[,2],linear=req2$conc[,2],
  equip=req3$conc[,2],equipS=req4$conc[,2])
cbind(rscale,linear=req2$see,equip=req3$see,equipS=req4$see)

#--------------------------------------------------------------
# nonequivalent groups design for (1) Tucker linear, and
# (2, 3) frequency estimation with weights of 0 and 1

nx <- KBneat$x
ny <- KBneat$y
nscale <- 0:36

neq1 <- equate(nx[,1],ny[,1],nscale,type="Linear",method="Tuck",
  xv=nx[,2],yv=ny[,2],w=1,vscale=0:12)
neq2 <- equate(nx[,1],ny[,1],nscale,type="equip",method="freq",
  xv=nx[,2],yv=ny[,2],w=1,vscale=0:12)
neq3 <- equate(nx[,1],ny[,1],nscale,type="equip",method="freq",
  xv=nx[,2],yv=ny[,2],w=0,vscale=0:12)

# compare equated scores:
cbind(nscale,Tucker=neq1$conc[,2],FEw1=neq2$conc[,2],
  FEw.0=neq3$conc[,2])