etirm Namespace Reference

Classes
class	DiscreteLatentDist
	Class approximating the latent ability distribution by numeric quadrature. More...
class	NMatrixVec
	Helper class template used by EStepDiscrete for managing a vector containing pointers to RealMatrix objects. More...
class	EStepDiscrete
	Class template to perform E-step calculation and store results for IRT model with a discrete latent variable distribution. More...
class	Examinee
	Class to store a response pattern, its frequency, the posterior distribution of the ability parameter and the marginal likelihood of the pattern. More...
class	ExamineeGrpCov
	This class is a descendant of Examinee which also contains information about the group the examinee belongs to (a group covariate). More...
class	ICC3PLFunc
	Common functions and data members used for specializations of ICCLogistic. More...
class	ICCLogistic
	Class declaration of logistic item response model; specializations supplied for NPAR = 1, 2, 3. More...
class	ICCLogistic< 3 >
	Three-parameter logistic item response model. More...
class	ICCLogistic< 2 >
	Two-parameter logistic item response model. More...
class	ICCLogistic< 1 >
	One-parameter logistic item response model. More...
class	ICRF_GPCM
	Class for the GPCM item response function. More...
class	ICRF_PCM
	Class for Masters' PCM item response function. More...
class	Item
	Class (template) containing information about an item. More...
class	ItemDichotomous
	Class representing a dichotomously scored item derived from ItemNR. More...
class	ItemNR
	Class, derived from Item, to maintain information calculated for an Item object in the E-step so that it can be used in the M-step to estimate item parameters. More...
class	ItemParamPrior
	Class representing a prior distribution used for item parameters in Bayes modal estimation. More...
class	ItemParamPriorBeta4
	Class representing a four-parameter beta prior distribution of item parameters in Bayes modal estimation. More...
class	ItemParamPriorLogNormal
	Class derived from ItemParamPrior representing a lognormal prior distribution of item parameters for use in Bayes modal estimation. More...
class	ItemParamPriorNormal
	Class derived from ItemParamPrior representing a normal prior distribution of item parameters for use in Bayes modal estimation. More...
class	ItemPolytomous
	Class representing a polytomously scored item derived from ItemNR class. More...
class	ItemRespCounts
	Class to hold counts of number of examinees who responded in each response category of an item. More...
class	SwigEtirmRun
	Class holding information used for one modeling problem. More...
class	estep
	SWIG wrapper for EStepDiscrete object. More...
class	ThetaLogLikelihood
	Function object for computing loglikelihood for theta parameter of an IRT model. More...
Typedefs
typedef ETIRM_FLOAT_TYPE	Real
	Data type for floating point numbers.
typedef ETIRM_RESPONSE_TYPE	Response
	Data type to hold an examinee item response.
typedef SCPPNT::Vector< Real >	RealVector
	Vector type containing floating point numbers. Used in numeric calculations.
typedef SCPPNT::Matrix< Real >	RealMatrix
	Matrix type containing floating point numbers. Used in numeric calculations.
typedef SCPPNT::LogicError	LogicError
	Using SCPPNT exception types for logical errors.
typedef SCPPNT::InvalidArgument	InvalidArgument
	Using SCPPNT exception types for invalid arguments.
typedef SCPPNT::RuntimeError	RuntimeError
	Using SCPPNT exception types for runtime errors.
typedef SCPPNT::Exception	Exception
	Using SCPPNT exception types for exception violations.
typedef std::vector < ItemParamPrior * >	PriorVector
	Data type to represent a vector of pointers to prior distributions.
typedef RealVector	double_vector
	Vector type for double precision values.
typedef SCPPNT::Vector< int >	int_vector
	Vector type for integer values.
typedef std::vector< item_type * >	ItemVector
	Vector type for item pointers.
typedef EStepDiscrete < examinee_type, item_type, ItemVector::iterator, lvdist_type >	estep_type
	Class used in E-step calculation.
typedef std::vector< Uncmin < RealVector, RealMatrix, item_type > * >	UncminVector
	Container to hold Uncmin optimization objects.
typedef std::vector < examinee_type * >	ExamineeVector
	Container holding examinee object pointers.
typedef std::vector < ItemRespCounts * >	ItemStatsVector
	Container holding pointers to objects containing item statistics for each item.
Enumerations
enum	IRTModel {   OnePL, TwoPL, ThreePL, PCM,   GPCM }
	Enumeration for type of IRT model. More...
Functions
template<class URNG, class EI>
void	BootstrapSample (EI examinees_begin, EI examinees_end, URNG &rand)
	Generate a bootstrap sample for a group of examinees.
template<class PI, class WI>
void	DiscreteNormalDist (int nQuad, double minPoint, double maxPoint, PI ipoints, WI iweights, double mean=0.0, double sd=1.0)
	Compute points and weights for a discrete distribution that approximates a normal distribution.
template<class L>
Real	ExamineeThetaMLE (Real minTheta, Real maxTheta, Real precision, L &likelihood)
	Compute latent variable estimate for an examinee using maximum likelihood. Returns the latent trait estimate for the examinee.
template<class II, class IR>
Real	ExamineeThetaMLE (Real minTheta, Real maxTheta, Real precision, II items_begin, II items_end, IR responses_begin)
	Compute latent variable estimate for an examinee using maximum likelihood, create a ThetaLogLikelihood object from two item iterators and an interator to the examinee responses, and return the latent trait estimate for the examinee.
double	MaxRelParamDiff (RealVector &oldParam, RealVector &newParam, Real typicalValue=1.0)
	Returns the maximum relative difference between an old and new set of item parameters.
template<class MI, class II>
int	MStepItems (MI min_routines, II item_begin, II item_end, double &maxreldiff, bool ignoreMaxIter=false)
	Executes M-step for each item.
template<class II, class T, class R, class RI>
void	SimulateResponses (II item_begin, II item_end, T &theta, R &rand, RI iresp, bool resp_indices=false)
	Simulate responses to a set of items for a specific latent variable value.
template<class RI, class II>
void	PersonMoments (RI iresp, II iitem, RealVector &itemdiff, Response notPresentedResponse, Real *mean, Real *variance)
	Compute mean and standard deviation of logit item difficulty over items responded to by an examinee.
template<class IE, class RI>
void	ItemMoments (int num_examinees, IE begin_examinee, int item, RealVector &abilities, Response notPresentedResponse, double *mean, double *variance)
	Compute mean and standard deviation of person ability over examinees who reponded to an item.
template<class EI, class RI, class II>
void	PROX (int numItems, bool useAll, EI begin_examinee, EI end_examinee, II begin_item, Response notPresentedResponse, RealVector &itemdiff, RealVector &abilities)
	Compute Rasch item difficulties and examinee abilities using the Normal Approximation Estimation Algorithm (PROX).
template<class I>
void	AssignItemNR (int n, RealVector::iterator itemTheta, RealVector::iterator nVec, RealVector::iterator rVec, I *item)
	Assigns individual examinee thetas into discrete latent variable categories and updates expected counts n and r for item M-step.
template<class RI, class MI, class EI, class I, class II>
int	StartingValues3PL (MI begin_min, EI begin_examinee, EI end_examinee, II begin_item, II end_item, Response notPresentedResponse, bool useAll=false, int baseGroup=1, std::set< I * > *calc_items=0)
	Computes starting values for a sequence of items modeled with the three-parameter logistic model.
void	CheckItemParam (item_type *item, int index, const char *funcname)
	Tests whether item parameter index is valid for the item.
ItemParamPrior *	CreatePrior (const std::string &pstr, const double_vector &priorparam, const char *funcname)
	Create a prior distribution object and return a pointer to it.
char	Resp2Char (Response r, const item_type *item)
	Converts a response for an item into a character, where '0' represents the first response, '1' represents the second response, etc.
void	set_missing_resp (char nr)
	Assigns missing response code to identify examinees who did not respond to an item.
int	num_items ()
	Returns the number of items.
int	num_latent_dist_points ()
	Returns number of categories of the discrete theta distribution.
int	num_groups ()
	Returns number of examinee groups.
int	num_examinees ()
	Returns number of examinees.
const char *	item_get_model (int itemno)
	Returns the name of model used for an item.
void	item_set_param (int paramno, int itemno, double paramvalue)
	Assigns a value to one item parameter of an item.
void	item_set_params (int itemno, double_vector *params)
	Assigns values to all item parameters of an item.
void	item_set_all_params (int itemno, double_vector *params)
	Assigns values to all fixed and estimated item parameters of an item.
double	item_get_param (int paramno, int itemno)
	Returns value of one item parameter of an item.
double_vector *	item_get_params (int itemno)
	Returns vector of all estimated item parameters values of an item.
double_vector *	item_get_all_params (int itemno)
	Returns vector of all fixed and estimated item parameters values of an item.
int	item_num_params (int itemno)
	Returns the number of parameters of an item.
int	item_num_resp_cat (int itemno)
	Returns the number of response categories of an item.
void	item_set_prior (int paramno, int itemno, char *priortype, double_vector *dlist)
	Assigns prior distribution parameters for one item parameter.
const char *	item_get_prior_type (int paramno, int itemno)
	Returns type of prior distribution ("normal", "lognormal", "beta", "none") for one item parameter.
double_vector *	item_get_prior_param (int paramno, int itemno)
	Returns vector of prior distribution parameters for one item parameter.
double_vector *	item_cat_counts (int itemno, int group)
	Returns vector of response counts in each response category of an item.
double	item_resp_count (int itemno, int group)
	Returns the number of examinees responding to an item.
int	item_scale_params (int itemno, double slope, double intercept, bool ignorePriorError)
	Transforms the parameter estimates of an item to a different latent variable scale.
double	item_prob_resp (int itemno, int response, double theta)
	Returns the probability that an examinee with a particular theta value will give a particular response to a particular item.
double_vector *	test_characteristic_curve (double_vector *thetas, int_vector *ilist2)
	Returns a vector of values of the test characteristic curve, given a vector of theta values and a selection of items.
void	dist_set_points (double_vector *dlist, int group)
	Assigns quadrature point values to each discrete category of the discrete latent variable distribution.
void	dist_set_point (int index, double p, int group)
	Assigns a quadrature point value to one discrete category of the discrete latent variable distribution.
double_vector *	dist_get_points (int group)
	Returns vector of quadrature point values of the discrete latent variable distribution.
double	dist_get_point (int index, int group)
	Returns the quadrature point value of one discrete category of the discrete latent variable distribution.
void	dist_set_probs (double_vector *dlist, int group)
	Assigns quadrature weights to the quadrature points of the latent variable distribution.
void	dist_set_prob (int index, double w, int group)
	Assigns the quadrature weight to one discrete category of the discrete latent variable distribution.
double_vector *	dist_get_probs (int group)
	Returns vector of quadrature weights of the latent variable distribution for one group of examinees.
double	dist_get_prob (int index, int group)
	Returns the quadrature weight of one discrete category of the latent variable distribution for one group of examinees.
void	dist_transform (double slope, double intercept)
	Transforms the quadrature points of latent variable distribution to a new scale.
double_vector *	dist_scale (double mean, double sd, int group)
	Scales to the quadrature points of latent variable distribution to yield a specfic mean and standard deviation in one group.
double_vector *	dist_mean_sd (int group)
	Returns a vector with the mean and standard deviation of the latent variable distribution for a selected group of examinees.
int	dist_unique_points ()
	Returns 1 if unique sets of quadrature points are used for two or more groups of examinees, or returns 0 otherwise.
double_vector *	normal_dist_prob (int npoints, double minPoint, double maxPoint, double mean, double sd)
	Returns a vector of probabilities for a discrete distribution to approximate a normal distribution over a set of equally spaced points.
double_vector *	normal_dist_points (int npoints, double minPoint, double maxPoint, double mean, double sd)
	Returns a vector of quadrature points for a discrete distribution over a set of equally-spaced points.
int	mstep_items (bool ignore_max_iter, int_vector *itemno)
	CalculateS M-step for a set of items.
int	mstep_message (int itemno)
	Returns message from M-step minimization for one item.
void	mstep_max_iter (int itemno, int maxiter)
	Assigns the maximum number of iterations permitted with optimization procedure in mstep_items for one item.
double	mstep_max_diff ()
	Returns the maximum relative difference between parameter estimates in two successive EM iterations, as computed in last call to mstep_items.
double	mstep_dist (estep *e, int group)
	Executes M-step for the latent distribution in one group.
int	add_examinee (int_vector *responses, int group, double count)
	Add an examinee objec to the end of the examinee vector.
int_vector *	examinee_responses (int examineeno)
	Returns pointer to an integer vector of examinee item responses to all items.
const char *	examinee_response_str (int examineeno)
	Returns string containing (character) examinee responses to all items.
int	examinee_get_group (int examineeno)
	Return the number of the group the examinee belongs to.
void	examinee_set_group (int examineeno, int group)
	Assigns which group the examinee belongs to.
void	examinee_set_count (int examineeno, double count)
	Assigns the count (or weight) of the examinee.
double	examinee_get_count (int examineeno)
	Returns the count (or weight) of the examinee.
void	examinee_set_posterior (int examineeno, double_vector *posterior)
	Assigns posterior distribution of an examinee.
double_vector *	examinee_get_posterior (int examineeno)
	Returns pointer to vector of the posterior distribution of an examinee.
double	examinee_posterior_mean (int examineeno)
	Returns means of an examinee's posterior distribution.
double	examinee_theta_MLE (int examineeno, double minTheta, double maxTheta, double precision, int_vector *itemno5)
	Returns an examinee's maximum likelihood estimate of theta.
double	examinees_count (int group)
	Returns total examinee count in an examinee group (1, 2, ...), or across all groups.
void	bootstrap_seed (unsigned long seed)
	Assigns seed of random number generator used for bootstrap samples.
void	bootstrap_sample ()
	Generate bootstrap sample of examinees.
void	simulate_seed (unsigned long seed)
	Assigns seed of random number generator used for simulating item responses.
int_vector *	simulate_responses (double theta, int_vector *itemno2)
	Simulates item responses (integers) for a specific value of the latent variable.
const char *	simulate_response_str (double theta, int_vector *itemno2)
	Simulates item responses (characters) for a specific value of the latent variable.
int_vector *	get_responses (char *line, int_vector *offset, int_vector *len)
	Reads item responses from an input record.
int_vector *	get_responses_missing (char *line, int_vector *offset, int_vector *len, int_vector *items)
	Read item responses from a string where responses to only some items are present. The responses to the remaining items are assumed to be missing.
void	CheckRunInit ()
	Check that new_etirm has been called.
template<class V>
V	ItemSubset (int_vector *itemnums, V &all, const char *funcname)
	Creates a container holding the elements corresponding to a subset of items.
Variables
const double	logZero = -1021.0
	Value used to represent the log of zero probabilities.
const Real	invalidLogit = 10000.0
	value to indicate invalid logit (e.g., logit(1))
SwigEtirmRun *	gEtirmRun = 0
	Global variable holding information about a run.

---

Typedef Documentation

typedef RealVector etirm::double_vector

Vector type for double precision values.

Definition at line 52 of file swig_etirm.h.

typedef EStepDiscrete<examinee_type, item_type, ItemVector::iterator, lvdist_type> etirm::estep_type

Class used in E-step calculation.

Definition at line 61 of file swig_etirm.h.

typedef std::vector<examinee_type *> etirm::ExamineeVector

Container holding examinee object pointers.

Definition at line 67 of file swig_etirm.h.

typedef SCPPNT::Exception etirm::Exception

Using SCPPNT exception types for exception violations.

Definition at line 112 of file etirmtypes.h.

typedef SCPPNT::Vector<int> etirm::int_vector

Vector type for integer values.

Definition at line 55 of file swig_etirm.h.

typedef SCPPNT::InvalidArgument etirm::InvalidArgument

Using SCPPNT exception types for invalid arguments.

Definition at line 106 of file etirmtypes.h.

typedef std::vector<ItemRespCounts *> etirm::ItemStatsVector

Container holding pointers to objects containing item statistics for each item.

Definition at line 155 of file swig_etirm.h.

typedef std::vector<item_type *> etirm::ItemVector

Vector type for item pointers.

Definition at line 58 of file swig_etirm.h.

typedef SCPPNT::LogicError etirm::LogicError

Using SCPPNT exception types for logical errors.

Definition at line 103 of file etirmtypes.h.

typedef std::vector<ItemParamPrior *> etirm::PriorVector

Data type to represent a vector of pointers to prior distributions.

Definition at line 126 of file ItemParamPrior.h.

typedef ETIRM_FLOAT_TYPE etirm::Real

Data type for floating point numbers.

This type is defined globally rather than being a template parameter in individual classes because it seemed unlikely that one would want different floating point types used for different ETIRM classes.

Definition at line 84 of file etirmtypes.h.

typedef SCPPNT::Matrix<Real> etirm::RealMatrix

Matrix type containing floating point numbers. Used in numeric calculations.

Definition at line 100 of file etirmtypes.h.

typedef SCPPNT::Vector<Real> etirm::RealVector

Vector type containing floating point numbers. Used in numeric calculations.

Definition at line 93 of file etirmtypes.h.

typedef ETIRM_RESPONSE_TYPE etirm::Response

Data type to hold an examinee item response.

Definition at line 87 of file etirmtypes.h.

typedef SCPPNT::RuntimeError etirm::RuntimeError

Using SCPPNT exception types for runtime errors.

Definition at line 109 of file etirmtypes.h.

typedef std::vector<Uncmin<RealVector, RealMatrix, item_type> *> etirm::UncminVector

Container to hold Uncmin optimization objects.

Definition at line 64 of file swig_etirm.h.

---

Enumeration Type Documentation

enum etirm::IRTModel

Enumeration for type of IRT model.

Enumerator:

OnePL	One-parameter logistic for dichotomous items.
TwoPL	Two-parameter logistic for dichotomous items.
ThreePL	Three-parameter logistic for dichotomous items.
PCM	Partial credit model for polytomous items.
GPCM	Generalized partial credit model for polytomous items.

Definition at line 115 of file etirmtypes.h.

  {
    //! One-parameter logistic for dichotomous items.
    OnePL,
    //! Two-parameter logistic for dichotomous items.
    TwoPL,
    //! Three-parameter logistic for dichotomous items.
    ThreePL,
    //! Partial credit model for polytomous items
    PCM,
    //! Generalized partial credit model for polytomous items
    GPCM
  };

---

Function Documentation

int etirm::add_examinee	(	int_vector *	responses,
		int	group,
		double	count
	)

Add an examinee objec to the end of the examinee vector.

Returns the examinee number corresponding to this examinee.

Function Parameters

Parameters:

[in]	*responses	Pointer to vector of integer-formatted item responses. A negative integer indicates the examinee did not respond to the item. The integers representing responses are zero-offset (A response in the first response category is represented as zero).
[in]	group	Integer from 1 to maximum number of examinee groups giving the group the examinee belongs to.
[in]	count	Frequency given to response pattern (usually, count = 1).

Definition at line 1514 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), etirm::SwigEtirmRun::examineeCounts, etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::SwigEtirmRun::items, etirm::SwigEtirmRun::itemStats, etirm::SwigEtirmRun::numItems, etirm::Examinee< R, P >::SetCount(), and etirm::Examinee< R, P >::SetResponses().

  {
    const char *fname = "add_examinee";
    CheckRunInit();
    gEtirmRun->CheckGroup(group, fname);

    int len = responses->size();

    if (len != gEtirmRun->numItems)
    {
      throw RuntimeError("Invalid number of item responses", fname);
    }

    examinee_type *e = new examinee_type(len, group);

    ResponseVector r(len);
    ItemVector::iterator iitem = (gEtirmRun->items).begin();
    int_vector::iterator iir = responses->begin();
    ResponseVector::iterator ir = r.begin();
    ItemStatsVector::iterator is = (gEtirmRun->itemStats).begin();
    Response np = Item<Real>::NotPresentedResponse();
    for (; len--; ++iitem, ++iir, ++ir, ++is)
    {
      if (*iir < 0)
        *ir = np;
      else
      {
        *ir = (*iitem)->IndexResponse(*iir);
        if (!((*iitem)->ValidResponse(*ir)))
        {
          throw RuntimeError("Invalid item response", fname);
        }
        (*is)->AddResponse(*iir+1, count, group);
      }
    }

    e->SetResponses(r);
    e->SetCount(count);

    (gEtirmRun->examinees).push_back(e);

    (gEtirmRun->examineeCounts)[0] += count; // total count
    (gEtirmRun->examineeCounts)[group] += count; // group count

    return (gEtirmRun->examinees).size();
  }

Here is the call graph for this function:

template<class I>

void etirm::AssignItemNR	(	int	n,
		RealVector::iterator	itemTheta,
		RealVector::iterator	nVec,
		RealVector::iterator	rVec,
		I *	item
	)			[inline]

Assigns individual examinee thetas into discrete latent variable categories and updates expected counts n and r for item M-step.

Given category values of the discrete latent variable as c_1, c_2, ..., c_ncat, classifies individual thetas into categories using ncat-1 cutpoints (c_1+c_2)/2, (c_2+c_3)/2,..., where the examinee is classified into the first category if the theta value is less than (c_1+c_2)/2, into the second category if their theta value is greater than or equal to (c_1+c_2)/2 and less than (c_2+c_3)/2, etc.

Template Parameters

Parameters:

I

Item type.

Function Parameters

Parameters:

[in,out]	n	Number of examinees who respond to the item on input, 0 on output.
[in]	itemTheta	Vector of thetas for examinees who reponded to an item.
[in,out]	nVec	Iterator to vector of expected item response counts for each theta value?
[in,out]	rVec	Iterator to vector of expected number correct counts for each theta value?.
[in,out]	*item	Pointer to item object.

Definition at line 376 of file Start3PL.h.

  {
    int i;

    int ncat = item->NumLatentVarCat();

    if (ncat == 0)
      throw RuntimeError("Values of discrete latent variable categories are missing for an item",
          "AssignItemNR");

    /* Compute cutpoints for categorizing individual latent variable values */
    RealVector cutpoints(ncat-1);
    RealVector::iterator ic = cutpoints.begin();
    typename I::point_iterator ip = item->GetLatentVarPoints(1); // use points for first group
    for (i=ncat-1; i--; ++ic, ++ip)
    {
      *ic = (ip[0] + ip[1]) / 2.0;
    }

    item->InitializeNR();
    typename I::n_iterator in = item->NVector();
    typename I::r_iterator ir = item->RVector(item->CorrectResponse());
    for (; n--; ++itemTheta, ++nVec, ++rVec)
    {
      /* find category for theta using inefficient linear search */
      ic = cutpoints.begin();
      for (i=0; i<ncat-1; ++i, ++ic)
      {
        if (*itemTheta < *ic)
          break;
      }

      in[i] += *nVec;
      ir[i] += *rVec;
    }
  }

void etirm::bootstrap_sample

(

)

Generate bootstrap sample of examinees.

Definition at line 1944 of file swig_etirm.cpp.

References BootstrapSample(), etirm::SwigEtirmRun::CheckExaminees(), CheckRunInit(), etirm::SwigEtirmRun::examineeCounts, etirm::SwigEtirmRun::examinees, gEtirmRun, and etirm::SwigEtirmRun::rand_boot.

  {
    CheckRunInit();
    gEtirmRun->CheckExaminees("bootstrap_sample");

    if (!gEtirmRun->rand_boot)
      gEtirmRun->rand_boot = new random_type();

    boost::uniform_int<random_type> urand(*(gEtirmRun->rand_boot), 1, (gEtirmRun->examinees).size());

    BootstrapSample((gEtirmRun->examinees).begin(), (gEtirmRun->examinees).end(), urand);

    // Set vector of examinee counts
    gEtirmRun->examineeCounts = 0.0; // initialize to zero
    ExamineeVector::iterator ie = (gEtirmRun->examinees).begin();
    for (int i = (gEtirmRun->examinees).size(); i--; ++ie)
    {
      double count = (*ie)->Count();
      (gEtirmRun->examineeCounts)[0] += count; // total count
      int group = (*ie)->Group();
      (gEtirmRun->examineeCounts)[group] += count; // group count
    }
  }

Here is the call graph for this function:

void etirm::bootstrap_seed

(

unsigned long

seed

)

Assigns seed of random number generator used for bootstrap samples.

Function Parameters

Parameters:

[in]

seed

Seed value, 0 <= seed <= 4,294,967,295.

Definition at line 1923 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::rand_boot.

  {
    CheckRunInit();

    // convert to type used for seed in boost random number library
    boost::uint32_t boost_seed = seed;

    if (gEtirmRun->rand_boot)
    {
      gEtirmRun->rand_boot->seed(boost_seed);
    }
    else
    {
      gEtirmRun->rand_boot = new random_type(boost_seed);
    }
  }

Here is the call graph for this function:

template<class URNG, class EI>

void etirm::BootstrapSample	(	EI	examinees_begin,
		EI	examinees_end,
		URNG &	rand
	)			[inline]

Generate a bootstrap sample for a group of examinees.

Template parameters

Parameters:

	URNG	Type of function object returning uniform random numbers over the integers 1 to the number of examines. An example of a type that meets the requirements for this function is the uniform_int class from the boost library (http://www.boost.org).
	EI	Type of iterator over pointers to examinee objects.

Arguments

Parameters:

	examinees_begin	Iterator to pointer to first examinee.
	examinees_end	- Iterator to one past pointer to last examinee.

Definition at line 48 of file BootstrapSample.h.

Referenced by bootstrap_sample().

  {
    // Number of examinees
    std::iterator_traits<EI>::difference_type n = std::distance(examinees_begin, examinees_end);

    if (rand.min() != 1 || rand.max() != n)
    {
      throw InvalidArgument("Invalid range for random number generator",
          "SCPPNT::BootstrapSample");
    }

    // Create vector to hold counts for each examinee from bootstrap sample - initially zero
    std::vector<int> counts(n, 0);

    // generate bootstrap counts
    for (int i=0; i<n; ++i)
    {
      ++counts[rand()-1];
    }

    // Assign counts to examinees
    for (std::vector<int>::iterator ic = counts.begin(); examinees_begin != examinees_end; ++ic,
        ++examinees_begin)
    {
      (*examinees_begin)->SetCount(*ic);
    }
  }

Here is the caller graph for this function:

void etirm::CheckItemParam	(	item_type *	item,
		int	index,
		const char *	funcname
	)

Tests whether item parameter index is valid for the item.

Function Parameters

Parameters:

[in]	*item	Pointer to item object for which index is checked.
[in]	index	Zero-offset index of item parameter.
[in]	*funcname	pointer to name of calling function (used in error message).

Function Parameters

Parameters:

[in]	*item	Pointer to item object for which index is checked.
[in]	index	Zero-offset index of item parameter.
[in]	*funcname	pointer to name of calling function (used in error message).

Definition at line 284 of file swig_etirm.cpp.

References gEtirmRun, etirm::Item< L >::Index(), etirm::Item< L >::NumParameters(), and etirm::SwigEtirmRun::returnString.

Referenced by item_get_param(), item_get_prior_param(), item_get_prior_type(), item_set_param(), and item_set_prior().

  {
    if (item->NumParameters() <= index || index < 0)
    {
      char errstr[100];
      std::sprintf(errstr, "Invalid item parameter index for item %d: %d", item->Index()+1, index);
      gEtirmRun->returnString = errstr;
      throw RuntimeError((gEtirmRun->returnString).c_str(), funcname);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void etirm::CheckRunInit

(

)

Check that new_etirm has been called.

Note: This function is not defined in swig_etirm.cpp, it must be defined somewhere in the application.

Referenced by add_examinee(), bootstrap_sample(), bootstrap_seed(), etirm::estep::compute(), dist_get_point(), dist_get_points(), dist_get_prob(), dist_get_probs(), dist_mean_sd(), dist_scale(), dist_set_point(), dist_set_points(), dist_set_prob(), dist_set_probs(), dist_transform(), dist_unique_points(), etirm::estep::estep(), examinee_get_count(), examinee_get_group(), examinee_get_posterior(), examinee_posterior_mean(), examinee_response_str(), examinee_responses(), examinee_set_count(), examinee_set_group(), examinee_set_posterior(), examinee_theta_MLE(), examinees_count(), get_responses(), get_responses_missing(), item_cat_counts(), item_get_all_params(), item_get_model(), item_get_param(), item_get_params(), item_get_prior_param(), item_get_prior_type(), item_num_params(), item_num_resp_cat(), item_prob_resp(), item_resp_count(), item_scale_params(), item_set_all_params(), item_set_param(), item_set_params(), item_set_prior(), mstep_dist(), mstep_items(), mstep_max_diff(), mstep_max_iter(), mstep_message(), num_examinees(), num_groups(), num_items(), num_latent_dist_points(), simulate_response_str(), simulate_responses(), simulate_seed(), and test_characteristic_curve().

ItemParamPrior * etirm::CreatePrior	(	const std::string &	pstr,
		const double_vector &	priorparam,
		const char *	funcname
	)

Create a prior distribution object and return a pointer to it.

Function Parameters

Parameters:

[in]	pstr	Type of prior distribution, valued as ("none", "normal", "lognormal", "beta").
[in]	priorparam	Parameters of prior distribution.
[in]	funcname	Name of calling function (used in error messages)

Definition at line 305 of file swig_etirm.cpp.

Referenced by item_set_prior().

  {
    const char *err_message = "Invalid number of prior parameters";

    if (pstr.compare("none") == 0)
    {
      return 0;
    }
    else if (pstr.compare("normal") == 0)
    {
      if (priorparam.size() != 2)
        throw RuntimeError(err_message, funcname);
      return new ItemParamPriorNormal(priorparam[0], priorparam[1]);
    }
    else if (pstr.compare("lognormal") == 0)
    {
      if (priorparam.size() != 2)
        throw RuntimeError(err_message, funcname);
      return new ItemParamPriorLogNormal(priorparam[0], priorparam[1]);
    }
    else if (pstr.compare("beta") == 0)
    {
      if (priorparam.size() != 4)
        throw RuntimeError(err_message, funcname);
      return new ItemParamPriorBeta4(priorparam[0], priorparam[1], priorparam[2], priorparam[3]);
    }
    else
    {
      throw RuntimeError("Invalid prior type", funcname);
    }
    return 0;
  }

Here is the caller graph for this function:

template<class PI, class WI>

void etirm::DiscreteNormalDist	(	int	nQuad,
		double	minPoint,
		double	maxPoint,
		PI	ipoints,
		WI	iweights,
		double	mean = 0.0,
		double	sd = 1.0
	)			[inline]

Compute points and weights for a discrete distribution that approximates a normal distribution.

DiscreteNormalDist

Arguments

nQuad Number of discrete points in distribution. minPoint Value of smallest point in distribution (must be smaller than the mean). maxPoint Value of largest point in distribution (must be larger than the mean). ipoints Iterator over nQuad points of distribution. iweights Iterator over nQuad probabilities corresponding to the points. mean Mean of normal distribution. sd Standard deviation of normal distribution.

Definition at line 56 of file DiscreteNormalDist.h.

Referenced by normal_dist_points(), normal_dist_prob(), and etirm::SwigEtirmRun::SwigEtirmRun().

{
  int i;
  
  if ((maxPoint-minPoint) <= 0.0 || minPoint > mean || maxPoint < mean) 
    throw InvalidArgument("Invalid minimum and maximum points", "DiscreteNormalDist");
  
  double incr = (maxPoint-minPoint) / (nQuad-1.0);
  
  PI points = ipoints;
  WI weights = iweights;
  double theta = minPoint;
  double sum = 0.0;
  for (i=nQuad; i--; ++points, ++weights)
  {
    *points = (theta - mean) / sd;
    *weights = std::exp(-0.5 * theta * theta);
    sum += *weights;
    theta += incr;
  }
  
  /* Standardize weights */
  weights = iweights;
  for (i=nQuad; i--; ++weights)
  {
    *weights /= sum;
  }
  
}

Here is the caller graph for this function:

double etirm::dist_get_point	(	int	index,
		int	group
	)

Returns the quadrature point value of one discrete category of the discrete latent variable distribution.

Function Parameters

Parameters:

[in]	index	Index of latent variable category (1, 2, ..., number of categories).
[in]	group	Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1136 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_get_point");

    if (index < 1 || index> (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Invalid category of latent variable distribution","dist_get_point");
    }

    DiscreteLatentDist<Real>::point_iterator ip = (gEtirmRun->latentDist).begin_points(group);

    return ip[index-1];
  }

Here is the call graph for this function:

double_vector * etirm::dist_get_points

(

int

group

)

Returns vector of quadrature point values of the discrete latent variable distribution.

Function Parameters

Parameters:

[in]

group

Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1109 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_get_points");

    DiscreteLatentDist<Real>::point_iterator ip = (gEtirmRun->latentDist).begin_points(group);

    int n = (gEtirmRun->latentDist).size();
    double_vector *outv = new double_vector(n);
    double_vector::iterator id = outv->begin();
    for (; n--; ++ip, ++id)
    {
      *id = *ip;
    }

    return outv;
  }

Here is the call graph for this function:

double etirm::dist_get_prob	(	int	index,
		int	group
	)

Returns the quadrature weight of one discrete category of the latent variable distribution for one group of examinees.

Function Parameters

Parameters:

[in]	index	Index of latent variable category (1, 2, ..., number of categories).
[in]	group	Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1253 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_get_prob");

    if (index < 1 || index> (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Invalid category of latent variable distribution","dist_get_prob");
    }

    DiscreteLatentDist<Real>::weight_iterator ip = (gEtirmRun->latentDist).begin_weights(group);

    return ip[index-1];
  }

Here is the call graph for this function:

double_vector * etirm::dist_get_probs

(

int

group

)

Returns vector of quadrature weights of the latent variable distribution for one group of examinees.

Function Parameters

Parameters:

[in]

group

Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1224 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_get_probs");

    DiscreteLatentDist<Real>::weight_iterator ip = (gEtirmRun->latentDist).begin_weights(group);

    int n = (gEtirmRun->latentDist).size();
    double_vector *outv = new double_vector(n);
    double_vector::iterator id = outv->begin();
    for (; n--; ++ip, ++id)
    {
      *id = *ip;
    }

    return outv;

  }

Here is the call graph for this function:

double_vector * etirm::dist_mean_sd

(

int

group

)

Returns a vector with the mean and standard deviation of the latent variable distribution for a selected group of examinees.

Function Parameters

Parameters:

[in]

group

Group to use as reference group (1, 2, ..., number of groups).

Definition at line 1320 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_mean_sd");

    double mean, sd;
    (gEtirmRun->latentDist).MeanSD(group, mean, sd);

    double_vector *outv = new double_vector(2);

    (*outv)[0] = mean;
    (*outv)[1] = sd;

    return outv;
  }

Here is the call graph for this function:

double_vector * etirm::dist_scale	(	double	mean,
		double	sd,
		int	group
	)

Scales to the quadrature points of latent variable distribution to yield a specfic mean and standard deviation in one group.

Function Parameters

Parameters:

[in]	mean	Mean of reference group after scaling the latent distribution.
[in]	sd	Standard deviation of reference group after scaling the latent distribution.
[in]	group	Group to use as reference group (1, 2, ..., number of groups).

Definition at line 1295 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_scale");

    double slope, intercept;
    (gEtirmRun->latentDist).Scale(mean, sd, group, slope, intercept);

    double_vector *outv = new double_vector(2);

    (*outv)[0] = slope;
    (*outv)[1] = intercept;

    return outv;
  }

Here is the call graph for this function:

void etirm::dist_set_point	(	int	index,
		double	p,
		int	group
	)

Assigns a quadrature point value to one discrete category of the discrete latent variable distribution.

Function Parameters

Parameters:

[in]	index	Index of latent variable category (1, 2, ..., number of categories).
[in]	p	Value to assign to point.
[in]	group	Group to use (1, 2, ..., number of groups), default = 1.

Latent distribution functions

Definition at line 1086 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_set_point");

    if (index < 1 || index> (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Invalid category of latent variable distribution","dist_set_point");
    }

    DiscreteLatentDist<Real>::point_iterator ip = (gEtirmRun->latentDist).begin_points(group);

    ip[index-1] = p;
  }

Here is the call graph for this function:

void etirm::dist_set_points	(	double_vector *	dlist,
		int	group
	)

Assigns quadrature point values to each discrete category of the discrete latent variable distribution.

Function Parameters

Parameters:

[in]	*dlist	Pointer to vector of quadrature points of the latent variable distribution.
[in]	group	Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1055 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_set_points");

    int n = dlist->size();
    if (n != (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Number of points does not match number of categories in latent distribution",
          "dist_set_points");
    }

    DiscreteLatentDist<Real>::point_iterator ip = (gEtirmRun->latentDist).begin_points(group);

    double_vector::iterator id = dlist->begin();
    for (; n--; ++ip, ++id)
    {
      *ip = *id;
    }
  }

Here is the call graph for this function:

void etirm::dist_set_prob	(	int	index,
		double	w,
		int	group
	)

Assigns the quadrature weight to one discrete category of the discrete latent variable distribution.

Function Parameters

Parameters:

[in]	index	Index of latent variable category (1, 2, ..., number of categories).
[in]	w	Value to assign to weight.
[in]	group	Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1200 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_set_prob");

    if (index < 1 || index> (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Invalid category of latent variable distribution","dist_set_prob");
    }

    DiscreteLatentDist<Real>::weight_iterator ip = (gEtirmRun->latentDist).begin_weights(group);

    ip[index-1] = w;
  }

Here is the call graph for this function:

void etirm::dist_set_probs	(	double_vector *	dlist,
		int	group
	)

Assigns quadrature weights to the quadrature points of the latent variable distribution.

Function Parameters

Parameters:

[in]	*dlist	Pointer to vector of quadrature weights of the latent variable distribution.
[in]	group	Group to use (1, 2, ..., number of groups), default = 1.

Definition at line 1160 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "dist_set_probs");

    int n = dlist->size();
    if (n != (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Number of probabilities does not match number of categories in latent distribution",
          "dist_set_probs");
    }

    // assign probabilities
    DiscreteLatentDist<Real>::weight_iterator ip = (gEtirmRun->latentDist).begin_weights(group);
    double_vector::iterator id = dlist->begin();
    Real sum = 0.0;
    for (; n--; ++ip, ++id)
    {
      *ip = *id;
      sum += *ip;
    }

    // standardize probabilities to they sum to 1
    ip = (gEtirmRun->latentDist).begin_weights(group);
    for (n = dlist->size(); n--; ++ip)
    {
      *ip /= sum;
    }
  }

Here is the call graph for this function:

void etirm::dist_transform	(	double	slope,
		double	intercept
	)

Transforms the quadrature points of latent variable distribution to a new scale.

Function Parameters

Parameters:

[in]	slope	Slope parameter of linear scale transformation.
[in]	intercept	Intercept parameter of linear scale transformation.

Definition at line 1277 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();

    (gEtirmRun->latentDist).Transform(slope, intercept);
  }

Here is the call graph for this function:

int etirm::dist_unique_points

(

)

Returns 1 if unique sets of quadrature points are used for two or more groups of examinees, or returns 0 otherwise.

Definition at line 1341 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();

    return ((gEtirmRun->latentDist).NumGroupsUnique() > 1 && (gEtirmRun->latentDist).NumGroups() > 1);
  }

Here is the call graph for this function:

double etirm::examinee_get_count

(

int

examineeno

)

Returns the count (or weight) of the examinee.

Function Parameters

Parameters:

[in]

examineeno

Number of examinee whose count (or weight) is to be returned.

Definition at line 1719 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::Examinee< R, P >::Count(), etirm::SwigEtirmRun::examinees, and gEtirmRun.

  {
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, "examinee_get_count");

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    return examinee->Count();
  }

Here is the call graph for this function:

int etirm::examinee_get_group

(

int

examineeno

)

Return the number of the group the examinee belongs to.

Function Parameters

Parameters:

[in]

examineeno

Number of examinee for whom group membership is to be returned.

Definition at line 1663 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, and etirm::ExamineeGrpCov< R, P >::Group().

  {
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, "examinee_group");

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    return examinee->Group();
  }

Here is the call graph for this function:

double_vector * etirm::examinee_get_posterior

(

int

examineeno

)

Returns pointer to vector of the posterior distribution of an examinee.

Function Parameters

Parameters:

[in]

examineeno

Number of examinee whose posterior is to be returned.

Definition at line 1782 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::Examinee< R, P >::NumLatentVarCat(), etirm::Examinee< R, P >::posterior_begin(), and etirm::SwigEtirmRun::returnString.

  {
    char *fname = "examinee_get_posterior";
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, fname);

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];
    int n = examinee->NumLatentVarCat();

    if (n == 0)
    {
      char merr[100];
      std::sprintf(merr, "Posterior has not been computed for examinee %d", examineeno);
      gEtirmRun->returnString = merr;
      throw RuntimeError((gEtirmRun->returnString).c_str(), fname);
    }

    double_vector *post = new double_vector(n);

    examinee_type::posterior_vector::iterator ie = examinee->posterior_begin();
    double_vector::iterator ip = post->begin();
    for (; n--; ++ie, ++ip)
    {
      *ip = *ie;
    }

    return post;
  }

Here is the call graph for this function:

double etirm::examinee_posterior_mean

(

int

examineeno

)

Returns means of an examinee's posterior distribution.

Posterior must have already been computed, for example, by estep_compute.

Function Parameters

Parameters:

[in]

examineeno

Number of examinee whose posterior mean is to be returned.

Definition at line 1821 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::SwigEtirmRun::latentDist, etirm::Examinee< R, P >::NumLatentVarCat(), etirm::Examinee< R, P >::posterior_begin(), and etirm::SwigEtirmRun::returnString.

  {
    char *fname = "examinee_posterior_mean";
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, fname);

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];
    int n = examinee->NumLatentVarCat();

    if (n == 0)
    {
      char merr[100];
      std::sprintf(merr, "Posterior distribution has not been computed for examinee %d", examineeno);
      gEtirmRun->returnString = merr;
      throw RuntimeError((gEtirmRun->returnString).c_str(), fname);
    }

    examinee_type::posterior_vector::iterator iw = examinee->posterior_begin();
    lvdist_type::point_iterator ip = (gEtirmRun->latentDist).begin_points();
    double mean = 0.0;
    for (; n--; ++iw, ++ip)
    {
      mean += *ip * *iw;
    }

    return mean;
  }

Here is the call graph for this function:

const char * etirm::examinee_response_str

(

int

examineeno

)

Returns string containing (character) examinee responses to all items.

A response in the first response category is '0', a response in the second category is '1', etc. Because each response is represented by a single character care must be taken when some items have more than 10 response categories. For example, a response in the 11th response category would be represented by the ascii character ':', which is the 10th character greater than '0' in the ascii character sequence.

Function Parameters

Parameters:

[in]

examineeno

Number of examinee for whom item responses are returned.

Definition at line 1624 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::SwigEtirmRun::items, etirm::Examinee< R, P >::NumItems(), Resp2Char(), etirm::Examinee< R, P >::responses_begin(), etirm::Examinee< R, P >::responses_end(), and etirm::SwigEtirmRun::returnString.

  {
    const char *fname = "examinee_response_str";
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, fname);

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    if ((gEtirmRun->items).size() != examinee->NumItems())
    {
      throw RuntimeError("Number of examinee responses does not match number of items", fname);
    }

    // iterators to first and one past last response
    examinee_type::response_iterator first = examinee->responses_begin();
    examinee_type::response_iterator last = examinee->responses_end();

    std::string &responseStr = gEtirmRun->returnString;
    responseStr.clear();
    ItemVector::iterator ii = (gEtirmRun->items).begin();
    while (first != last)
    {
      responseStr.push_back(Resp2Char(*first, *ii));
      ++ii;
      ++first;
    }

    return responseStr.c_str();
  }

Here is the call graph for this function:

int_vector * etirm::examinee_responses

(

int

examineeno

)

Returns pointer to an integer vector of examinee item responses to all items.

A non-negative integer indicates an examinee response in the category represented by the integer (0 = first response category, 1 = second response category, etc.). A negative integer indicates the examinee did not respond to the item.

Function Parameters

Parameters:

[in]

examineeno

Number of examinee for whom item responses are returned.

Definition at line 1574 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::SwigEtirmRun::items, etirm::Examinee< R, P >::NumItems(), etirm::Examinee< R, P >::responses_begin(), and etirm::Examinee< R, P >::responses_end().

  {
    const char *fname = "examinee_responses";
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, fname);

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    if ((gEtirmRun->items).size() != examinee->NumItems())
    {
      throw RuntimeError("Number of examinee responses does not match number of items", fname);
    }

    // iterators to first and one past last response
    examinee_type::response_iterator first = examinee->responses_begin();
    examinee_type::response_iterator last = examinee->responses_end();

    int_vector *responses = new int_vector(examinee->NumItems());
    int_vector::iterator ir = responses->begin();
    ItemVector::iterator ii = (gEtirmRun->items).begin();
    Response np = Item<Real>::NotPresentedResponse();
    while (first != last)
    {
      if (*first == np)
        *ir = -1;
      else
        *ir = (*ii)->ResponseIndex(*first);
      ++ir;
      ++ii;
      ++first;
    }

    return responses;
  }

Here is the call graph for this function:

void etirm::examinee_set_count	(	int	examineeno,
		double	count
	)

Assigns the count (or weight) of the examinee.

Function Parameters

Parameters:

[in]	examineeno	Number of examinee whose count (or weight) is to be assigned.
[in]	count	Count to be assigned to examinee.

Definition at line 1701 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, and etirm::Examinee< R, P >::SetCount().

  {
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, "examinee_set_count");

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    examinee->SetCount(count);
  }

Here is the call graph for this function:

void etirm::examinee_set_group	(	int	examineeno,
		int	group
	)

Assigns which group the examinee belongs to.

Function Parameters

Parameters:

[in]	examineeno	Number of examinee for whom group membership is to be assigned.
[in]	group	Group number to be assigned to examinee.

Definition at line 1682 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, and etirm::ExamineeGrpCov< R, P >::SetGroup().

  {
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, "examinee_set_group");

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    return examinee->SetGroup(group);
  }

Here is the call graph for this function:

void etirm::examinee_set_posterior	(	int	examineeno,
		double_vector *	posterior
	)

Assigns posterior distribution of an examinee.

Function Parameters

Parameters:

[in]	examineeno	Number of examinee whose posterior is to be assigned.
[in]	*posterior	Pointer to vector of posterior probabilities of the examinee.

Definition at line 1738 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::SwigEtirmRun::latentDist, etirm::SwigEtirmRun::numLatentCat, and etirm::Examinee< R, P >::SetPosterior().

  {
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, "examinee_set_posterior");

    if (posterior->size() != (gEtirmRun->latentDist).size())
    {
      throw RuntimeError("Invalid number of posterior probabilities",
          "examinee_set_posterior");
    }

    examinee_type *examinee = (gEtirmRun->examinees)[examineeno-1];

    examinee_type::posterior_vector epost(gEtirmRun->numLatentCat);
    examinee_type::posterior_vector::iterator iep = epost.begin();
    double_vector::iterator ip = posterior->begin();

    // assign probabilities
    int i;
    Real sum = 0.0;
    for (i = gEtirmRun->numLatentCat; i--; ++iep, ++ip)
    {
      *iep = *ip;
      sum += *iep;
    }

    // standardize probabilities to sum to 1.0
    iep = epost.begin();
    for (i = gEtirmRun->numLatentCat; i--; ++iep)
    {
      *iep /= sum;
    }

    examinee->SetPosterior(epost);
  }

Here is the call graph for this function:

double etirm::examinee_theta_MLE	(	int	examineeno,
		double	minTheta,
		double	maxTheta,
		double	precision,
		int_vector *	itemno5
	)

Returns an examinee's maximum likelihood estimate of theta.

Posterior must have already been computed, for example, by estep_compute.

Function Parameters

Parameters:

[in]	examineeno	Number of examinee whose theta MLE is to be returned (1 = first examinee).
[in]	minTheta	Minimum value of theta estimate.
[in]	maxTheta	Maximum value of theta estimate.
[in]	precision	Length of interval in which MLE is determined to lie. This should be greater than, roughly, 3.0e-8.
[in]	*itemno5	Pointer to a list of item numbers of the items to use in computing examinee MLE. If itemno5 = NULL, then all items will be used.

Definition at line 1865 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::base_rand_simulate, etirm::SwigEtirmRun::CheckExamineeNumber(), CheckRunInit(), etirm::SwigEtirmRun::examinees, gEtirmRun, etirm::SwigEtirmRun::items, ItemSubset(), and etirm::SwigEtirmRun::rand_simulate.

  {
    CheckRunInit();
    gEtirmRun->CheckExamineeNumber(examineeno, "examinee_theta_MLE");

    if (!gEtirmRun->base_rand_simulate)
    {
      gEtirmRun->base_rand_simulate = new random_type();
      gEtirmRun->rand_simulate = new boost::uniform_01<random_type>(*(gEtirmRun->base_rand_simulate));
    }

    ItemVector *sitems;
    if (itemno5)
    {
      sitems = new ItemVector(ItemSubset(itemno5, gEtirmRun->items, "examinee_theta_MLE"));
    }
    else
    {
      sitems = &(gEtirmRun->items);
    }

    double theta =
        ExamineeThetaMLE<ItemVector::iterator, examinee_type::response_vector::iterator>(minTheta,
            maxTheta, precision, sitems->begin(), sitems->end(), (gEtirmRun->examinees[examineeno-1])->responses_begin());

    if (itemno5)
      delete sitems;

    return theta;
  }

Here is the call graph for this function:

double etirm::examinees_count

(

int

group

)

Returns total examinee count in an examinee group (1, 2, ...), or across all groups.

Function Parameters

Parameters:

[in]

group

Group to return count for (1-offset). Specify group = 0 to return counts across all groups.

Definition at line 1906 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), etirm::SwigEtirmRun::examineeCounts, and gEtirmRun.

  {
    CheckRunInit();
    if (group != 0)
      gEtirmRun->CheckGroup(group, "examinee_count");

    return (gEtirmRun->examineeCounts)[group];
  }

Here is the call graph for this function:

template<class II, class IR>

Real etirm::ExamineeThetaMLE	(	Real	minTheta,
		Real	maxTheta,
		Real	precision,
		II	items_begin,
		II	items_end,
		IR	responses_begin
	)			[inline]

Compute latent variable estimate for an examinee using maximum likelihood, create a ThetaLogLikelihood object from two item iterators and an interator to the examinee responses, and return the latent trait estimate for the examinee.

Template Parameters

Parameters:

	II	Iterator type over pointers to item objects.
	IR	Iterator type over examinee responses to items.

Function Parameters

Parameters:

[in]	minTheta	Minimum value of theta estimate
[in]	maxTheta	Maximum value of theta estimate
[in]	precision	Length of interval in which MLE is determined to lie. This should be greater than, roughly, 3.0e-8.
[in]	items_begin	Iterator pointing to first item object pointer.
[in]	items_end	Iterator pointing to one past the last item object pointer.
[in]	responses_begin	Iterator pointing to examinee's response to first item.

Definition at line 100 of file ExamineeThetaMLE.h.

References ExamineeThetaMLE().

  {
    // Last argument being true indicates the function object
    // should return the negative of the likelihood since
    // the function will be minimized, not maximized.
    ThetaLogLikelihood<II,IR> likelihood(items_begin, items_end, responses_begin, true);

    return ExamineeThetaMLE(minTheta, maxTheta, precision, likelihood);

  }

Here is the call graph for this function:

template<class L>

Real etirm::ExamineeThetaMLE	(	Real	minTheta,
		Real	maxTheta,
		Real	precision,
		L &	likelihood
	)			[inline]

Compute latent variable estimate for an examinee using maximum likelihood. Returns the latent trait estimate for the examinee.

Template Parameters

Parameters:

L

Function type returning minus the loglihood. An object of this type is passed to minimization procedure.

Function Parameters

Parameters:

[in]	minTheta	Minimum value of theta estimate
[in]	maxTheta	Maximum value of theta estimate
[in]	precision	Length of interval in which MLE is determined to lie. This should be greater than, roughly, 3.0e-8.
[in]	likelihood	The function to minimize (minus the loglikelihood).

Definition at line 53 of file ExamineeThetaMLE.h.

Referenced by ExamineeThetaMLE().

  {
    Real midTheta = (minTheta + maxTheta) / 2.0;

    // See if middle value is bracketed
    Real fmin = likelihood(minTheta);
    Real fmid = likelihood(midTheta);
    Real fmax = likelihood(maxTheta);

    Real theta;

    // Compute minimum on two intervals and take the one corresponding to the largest
    // likelihood. This reduces the chances of a local minimum being identified by Fmin when the
    // function is multimodal and is not bracketed.
    fmin = Fmin(minTheta, midTheta, likelihood, precision);
    fmax = Fmin(midTheta, maxTheta, likelihood, precision);
    
    theta = (likelihood(fmin) < likelihood(fmax)) ? fmin : fmax;
    return theta;
  }

Here is the caller graph for this function:

int_vector * etirm::get_responses	(	char *	line,
		int_vector *	offset,
		int_vector *	len
	)

Reads item responses from an input record.

The item responses are assumed to be integers from 0 to one minus the maximum number of response categories for the item. A response representing a missing response is assigned -1.

Returns poiner to an integer vector containing thew item responses.

Function Parameters

Parameters:

[in]	*line	Pointer to character string to read the item responses from.
[in]	*offset	Pointer to vector of zero-based offsets of each item response in 'line'.
[in]	*len	Pointer to vector of field widths for each item response.

Definition at line 2102 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::returnString.

Referenced by get_responses_missing().

  {
    const char *fname = "get_responses";
    CheckRunInit();

    int n = offset->size();

    if (n != len->size())
    {
      throw InvalidArgument("Lengths of offset and length vectors do not match", fname);
    }

    int_vector *resp = new int_vector(n);

    int_vector::iterator ir = resp->begin();
    int_vector::iterator ioff = offset->begin();
    int_vector::iterator ilen = len->begin();
    Response np = Item<Real>::NotPresentedResponse();
    for (; n--; ++ioff, ++ilen, ++ir)
    {
      // Convert response to integer
      char *pos = line + *ioff + *ilen - 1;
      *ir = 0;
      int power = 1;
      for (int i=*ilen; i--; power *= 10, --pos)
      {
        if (*pos == np) // check for missing item response
        {
          *ir = -1;
          break;
        }
        else if ( (*pos < '0') && (*pos > '9')) // check that item response is valid // Sytax edited, ww, 2-24-2008.
        {
          char errstr[50];
          std::sprintf(errstr, "Invalid item response: %1c", *pos);
          gEtirmRun->returnString = errstr;
          throw RuntimeError((gEtirmRun->returnString).c_str(), fname);
        }
        *ir += power * (*pos - '0');
      }
    }

    return resp;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int_vector * etirm::get_responses_missing	(	char *	line,
		int_vector *	offset,
		int_vector *	len,
		int_vector *	items
	)

Read item responses from a string where responses to only some items are present. The responses to the remaining items are assumed to be missing.

The item responses are assumed to be integers from 0 to one minus the maximum number of response categories for the item. A response representing a missing response is assigned -1.

Returns poiner to an integer vector containing thew item responses.

Function Parameters

Parameters:

[in]	*line	Pointer to character string to read the item responses from.
[in]	*offset	Pointer to vector of zero-based offsets of each item response in 'line'.
[in]	*len	Pointer to vector of field widths for each item response.
[in]	*items	Pointer to vector 1-offset indices of items for which responses are read.

Definition at line 2165 of file swig_etirm.cpp.

References CheckRunInit(), get_responses(), gEtirmRun, and etirm::SwigEtirmRun::numItems.

  {
    const char *fname = "get_responses_missing";
    CheckRunInit();

    int n = offset->size();

    if (n != len->size() || n != items->size())
    {
      throw InvalidArgument("Lengths of vector arguments do not match", fname);
    }

    int_vector *resp = get_responses(line, offset, len);

    // initially assign all missing responses
    int nall = gEtirmRun->numItems;
    int_vector *allresp = new int_vector(nall, -1);

    // Assign responses read
    int_vector::iterator ir = resp->begin();
    int_vector::iterator ii = items->begin();
    for (; n--; ++ii, ++ir)
    {
      if ( (*ii < 1) || (*ii > nall)) // Syntax edited, ww, 2-24-2008.
      {
        delete resp;
        throw InvalidArgument("Invalid item number", fname);
      }
      (*allresp)[*ii-1] = *ir;
    }

    delete resp;

    return allresp;
  }

Here is the call graph for this function:

double_vector * etirm::item_cat_counts	(	int	itemno,
		int	group
	)

Returns vector of response counts in each response category of an item.

Function Parameters

Parameters:

[in]	itemno	Number of item for which response counts are returned (1-offset).
[in]	group	Group to return counts for (1-offset). Specify group = 0 to return counts across all groups.

Definition at line 897 of file swig_etirm.cpp.

References etirm::ItemRespCounts::CategoryCounts(), etirm::SwigEtirmRun::CheckGroup(), etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::itemStats.

  {
    const char *fname = "item_cat_counts";
    CheckRunInit();

    gEtirmRun->CheckItemNumber(itemno, fname);
    if (group != 0)
      gEtirmRun->CheckGroup(group, "item_resp_count");

    ItemRespCounts *stats = (gEtirmRun->itemStats)[itemno-1];

    double_vector *v = new double_vector(stats->CategoryCounts(group));

    return v;
  }

Here is the call graph for this function:

double_vector * etirm::item_get_all_params

(

int

itemno

)

Returns vector of all fixed and estimated item parameters values of an item.

Function Parameters

Parameters:

[in]

itemno

Item number (1-offset).

Note: The order of the parameters in the params vector is: a (if there is an a parameter), one or more b's, and c (if there is a c parameter).

Definition at line 727 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), etirm::Item< L >::GetAllParameters(), gEtirmRun, and etirm::SwigEtirmRun::items.

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "item_get_all_params");

    item_type *item = (gEtirmRun->items)[itemno-1];

    RealVector allparam = item->GetAllParameters();
    int n = allparam.size();
    double_vector *params = new double_vector(n);

    RealVector::iterator pv = allparam.begin();
    double_vector::iterator iv = params->begin();
    for (; n--; ++pv, ++iv)
    {
      *iv = *pv;
    }

    return params;
  }

Here is the call graph for this function:

const char * etirm::item_get_model

(

int

itemno

)

Returns the name of model used for an item.

Function Parameters

Parameters:

[in]

itemno

Item number (1-offset).

Definition at line 522 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, etirm::Item< L >::ModelName(), and etirm::SwigEtirmRun::returnString.

  {

    CheckRunInit();
    std::string &modelName = gEtirmRun->returnString;
    gEtirmRun->CheckItemNumber(itemno, "item_get_model");

    item_type *item = (gEtirmRun->items)[itemno-1];
    modelName = item->ModelName();

    return modelName.c_str();
  }

Here is the call graph for this function:

double etirm::item_get_param	(	int	paramno,
		int	itemno
	)

Returns value of one item parameter of an item.

Function Parameters

Parameters:

[in]	paramno	1-offset index of the parameter in the item's parameter vector.
[in]	itemno	Item number (1-offset).

Note: The order of the parameters in the params vector is: a (if there is an a parameter), one or more b's, and c (if there is a c parameter).

Definition at line 668 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckItemParam(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, and etirm::Item< L >::ParametersIterator().

  {
    const char *fname = "item_get_param";
    CheckRunInit();
    int index = paramno - 1;

    gEtirmRun->CheckItemNumber(itemno, fname);
    item_type *item = (gEtirmRun->items)[itemno-1];
    CheckItemParam(item, index, fname);

    item_type::param_iterator pv = item->ParametersIterator();

    return pv[index];
  }

Here is the call graph for this function:

double_vector * etirm::item_get_params

(

int

itemno

)

Returns vector of all estimated item parameters values of an item.

Function Parameters

Parameters:

[in]

itemno

Item number (1-offset).

Note: The order of the parameters in the params vector is: a (if there is an a parameter), one or more b's, and c (if there is a c parameter).

Definition at line 695 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, etirm::Item< L >::NumParameters(), and etirm::Item< L >::ParametersIterator().

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "item_get_params");

    item_type *item = (gEtirmRun->items)[itemno-1];

    int n = item->NumParameters();
    double_vector *params = new double_vector(n);

    item_type::param_iterator pv = item->ParametersIterator();
    double_vector::iterator iv = params->begin();
    for (; n--; ++pv, ++iv)
    {
      *iv = *pv;
    }

    return params;
  }

Here is the call graph for this function:

double_vector * etirm::item_get_prior_param	(	int	paramno,
		int	itemno
	)

Returns vector of prior distribution parameters for one item parameter.

Function Parameters

Parameters:

[in]	paramno	1-offset index of parameter in parameter vector for item.
[in]	itemno	Number of item for which prior is returned (1-offset).

Definition at line 858 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckItemParam(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, and etirm::Item< L >::PriorsIterator().

  {
    const char *fname = "item_get_prior_param";
    CheckRunInit();
    int index = paramno - 1;

    gEtirmRun->CheckItemNumber(itemno, fname);
    item_type *item = (gEtirmRun->items)[itemno-1];
    CheckItemParam(item, index, fname);

    item_type::prior_iterator pv = item->PriorsIterator() + index;

    double_vector *v;
    if (*pv != 0)
    {
      int n = (*pv)->NumParameters();

      v = new double_vector(n);

      *v = (*pv)->GetParameters();
    }
    else
    {
      v = new double_vector();
    }

    return v;
  }

Here is the call graph for this function:

const char * etirm::item_get_prior_type	(	int	paramno,
		int	itemno
	)

Returns type of prior distribution ("normal", "lognormal", "beta", "none") for one item parameter.

Function Parameters

Parameters:

[in]	paramno	1-offset index of parameter in parameter vector for item.
[in]	itemno	Number of item for which prior is returned (1-offset).

Definition at line 824 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckItemParam(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, etirm::Item< L >::PriorsIterator(), and etirm::SwigEtirmRun::returnString.

  {
    const char *fname = "item_get_prior_type";
    CheckRunInit();
    std::string &priorName = gEtirmRun->returnString;
    int index = paramno - 1;

    gEtirmRun->CheckItemNumber(itemno, fname);
    item_type *item = (gEtirmRun->items)[itemno-1];
    CheckItemParam(item, index, fname);

    item_type::prior_iterator pv = item->PriorsIterator() + index;

    if (*pv != 0)
    {
      priorName = (*pv)->DistributionName();
    }
    else
    {
      priorName = "none";
    }

    return priorName.c_str();
  }

Here is the call graph for this function:

int etirm::item_num_params

(

int

itemno

)

Returns the number of parameters of an item.

Function Parameters

Parameters:

[in]

itemno

Item number (1-offset).

Definition at line 756 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, and etirm::Item< L >::NumParameters().

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "item_num_params");

    item_type *item = (gEtirmRun->items)[itemno-1];

    return item->NumParameters();
  }

Here is the call graph for this function:

int etirm::item_num_resp_cat

(

int

itemno

)

Returns the number of response categories of an item.

Function Parameters

Parameters:

[in]

itemno

Item number (1-offset).

Definition at line 774 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, and etirm::Item< L >::NumRespCat().

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "item_num_resp_cat");

    item_type *item = (gEtirmRun->items)[itemno-1];

    return item->NumRespCat();
  }

Here is the call graph for this function:

double etirm::item_prob_resp	(	int	itemno,
		int	response,
		double	theta
	)

Returns the probability that an examinee with a particular theta value will give a particular response to a particular item.

Function Parameters

Parameters:

[in]	itemno	Number (1-based) of item for which response probability is returned.
[in]	response	Integer representing response, where a response in the first response category is 0, a response in the second response category is 1, etc.
[in]	theta	Value of latent variable for which response probability is returned.

Definition at line 970 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::Item< L >::IndexResponse(), etirm::SwigEtirmRun::items, and etirm::Item< L >::ProbResp().

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "item_prob_resp");

    item_type *item = (gEtirmRun->items)[itemno-1];

    return item->ProbResp(item->IndexResponse(response), theta);
  }

Here is the call graph for this function:

double etirm::item_resp_count	(	int	itemno,
		int	group
	)

Returns the number of examinees responding to an item.

Function Parameters

Parameters:

[in]	itemno	Number of item for which response counts are returned (1-offset).
[in]	group	Group to return counts for (1-offset). Specify group = 0 to return count across all groups.

Definition at line 923 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::itemStats.

  {
    CheckRunInit();

    gEtirmRun->CheckItemNumber(itemno, "item_resp_count");
    if (group != 0)
      gEtirmRun->CheckGroup(group, "item_resp_count");

    return (gEtirmRun->itemStats)[itemno-1]->RespCount(group);
  }

Here is the call graph for this function:

int etirm::item_scale_params	(	int	itemno,
		double	slope,
		double	intercept,
		bool	ignorePriorError
	)

Transforms the parameter estimates of an item to a different latent variable scale.

Returns zero if parameters are successfully scaled, or returns nonzero if scaling would result in an invalid parameter value.

Function Parameters

Parameters:

[in]	itemno	Number of item for which to transform parameters (1-offset).
[in]	slope	Slope of scale transformation to apply to item parameters.
[in]	intercept	Intercept of scale transformation to apply to item parameters.
[in]	ignorePriorError	If true then do not report an error if transformed parameter has zero density in prior used for that parameter.

Definition at line 948 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, and etirm::Item< L >::ScaleParameters().

  { // Retyped ignorePriorErro from "int" to "bool", ww, 2-24-2008.
    CheckRunInit();

    gEtirmRun->CheckItemNumber(itemno, "item_scale_params");
    item_type *item = (gEtirmRun->items)[itemno-1];

    return item->ScaleParameters(slope, intercept, ignorePriorError);
  }

Here is the call graph for this function:

void etirm::item_set_all_params	(	int	itemno,
		double_vector *	params
	)

Assigns values to all fixed and estimated item parameters of an item.

Function Parameters

Parameters:

[in]	itemno	Item number (1-offset).
[in]	*params	Pointer to params vector containing the values to set the parameters to.

Note: The order of the parameters in the params vector is: a (if there is an a parameter), one or more b's, and c (if there is a c parameter).

Definition at line 629 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, etirm::Item< L >::NumParameters(), etirm::Item< L >::ParametersIterator(), etirm::Item< L >::PriorsIterator(), etirm::SwigEtirmRun::returnString, and etirm::Item< L >::SetAllParameters().

  {
    const char *fname = "item_set_all_params";
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, fname);

    item_type *item = (gEtirmRun->items)[itemno-1];

    // Assign new fixed and estimated parameters
    item->SetAllParameters(*params);

    /* Check that values of estimated parameters all have nonzero prior density */
    item_type::param_iterator iv = item->ParametersIterator();
    item_type::prior_iterator pri = item->PriorsIterator();
    for (int n = item->NumParameters(); n--; ++pri, ++iv)
    {
      if (*pri && (*pri)->ZeroDensity(*iv))
      {
        char merr[100];
        std::sprintf(merr, "Parameter specified for item %d has zero prior density", itemno);
        gEtirmRun->returnString = merr;
        throw InvalidArgument((gEtirmRun->returnString).c_str(), fname);
      }
    }
  }

Here is the call graph for this function:

void etirm::item_set_param	(	int	paramno,
		int	itemno,
		double	paramvalue
	)

Assigns a value to one item parameter of an item.

Function Parameters

Parameters:

[in]	paramno	1-offset index of parameter in parameter vector for item.
[in]	itemno	Item number (1-offset).
[in]	paramvalue	Value parameter is set to.

Definition at line 545 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckItemParam(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, etirm::Item< L >::ParametersIterator(), etirm::Item< L >::PriorsIterator(), and etirm::SwigEtirmRun::returnString.

  {
    const char *fname = "item_set_param";
    CheckRunInit();
    int index = paramno - 1;

    gEtirmRun->CheckItemNumber(itemno, fname);
    item_type *item = (gEtirmRun->items)[itemno-1];
    CheckItemParam(item, index, fname);

    /* Check that value of parameter has nonzero prior density */
    item_type::prior_iterator pri = item->PriorsIterator() + index;
    if (*pri && (*pri)->ZeroDensity(paramvalue))
    {
      char merr[100];
      std::sprintf(merr, "Parameter specified for item %d has zero prior density", itemno);
      gEtirmRun->returnString = merr;
      throw RuntimeError((gEtirmRun->returnString).c_str(), fname);
    }

    item_type::param_iterator pv = item->ParametersIterator();

    pv[index] = paramvalue;
  }

Here is the call graph for this function:

void etirm::item_set_params	(	int	itemno,
		double_vector *	params
	)

Assigns values to all item parameters of an item.

Function Parameters

Parameters:

[in]	itemno	Item number (1-offset).
[in]	*params	Pointer to params vector containing the values to set the parameters to.

Note: The order of the parameters in the params vector is: a (if there is an a parameter), one or more b's, and c (if there is a c parameter).

Definition at line 584 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, etirm::Item< L >::NumParameters(), etirm::Item< L >::ParametersIterator(), and etirm::Item< L >::PriorsIterator().

  {
    const char *fname = "item_set_params";
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, fname);

    item_type *item = (gEtirmRun->items)[itemno-1];

    // Assign new parameters
    item_type::param_iterator pv = item->ParametersIterator();
    double_vector::iterator iv = params->begin();
    int n;
    for (n = item->NumParameters(); n--; ++pv, ++iv)
    {
      *pv = *iv;
    }

    /* Check that values of all parameters have nonzero prior density */
    iv = params->begin();
    item_type::prior_iterator pri = item->PriorsIterator();
    for (n = item->NumParameters(); n--; ++pri, ++iv)
    {
      if (*pri && (*pri)->ZeroDensity(*iv))
      {
        char merr[100];
        std::sprintf(merr, "Parameter specified for item %d has zero prior density", itemno);
        throw InvalidArgument(merr, fname);
      }
    }
  }

Here is the call graph for this function:

void etirm::item_set_prior	(	int	paramno,
		int	itemno,
		char *	priortype,
		double_vector *	dlist
	)

Assigns prior distribution parameters for one item parameter.

Function Parameters

Parameters:

[in]	paramno	1-offset index of parameter in parameter vector for item.
[in]	itemno	Number of item for which prior is set (1-offset).
[in]	*priortype	Pointer to type of prior distribution ("normal", "lognormal", "beta", "none").
[in]	*dlist	Pointer to vector of prior distribution parameters.

Definition at line 795 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckItemParam(), CheckRunInit(), CreatePrior(), gEtirmRun, etirm::SwigEtirmRun::items, and etirm::Item< L >::PriorsIterator().

  {
    const char *funcname = "item_set_prior";
    CheckRunInit();
    int index = paramno - 1;

    gEtirmRun->CheckItemNumber(itemno, funcname);
    item_type *item = (gEtirmRun->items)[itemno-1];
    CheckItemParam(item, index, funcname);

    item_type::prior_iterator pv = item->PriorsIterator() + index;

    if (*pv)
      delete *pv;

    std::string pstr(priortype);
    *pv = CreatePrior(pstr, *dlist, funcname);
  }

Here is the call graph for this function:

template<class IE, class RI>

void etirm::ItemMoments	(	int	num_examinees,
		IE	begin_examinee,
		int	item,
		RealVector &	abilities,
		Response	notPresentedResponse,
		double *	mean,
		double *	variance
	)			[inline]

Compute mean and standard deviation of person ability over examinees who reponded to an item.

Template Parameters

Parameters:

	EI	Type of iterator over examinees (iterator over pointers to Examinee objects)
	RI	Type of iterator over examinee responses (iterator returned by responses_begin() for an Examinee object)

Function Parameters

Parameters:

[in]	num_examinees	Number of examinees.
[in]	begin_examinee	Iterator to pointer to first examinee.
[in]	item	Index of item in response string to compute moments for (0 offset).
[in]	&abilities	Address of ability vector for all persons.
[in]	notPresentedResponse	Response which indicates an item was not presented to an examinee. Assumed to be the same for all items.
[out]	mean	Mean of abilities for persons resonding to the item.
[out]	variance	Variance of abilities for persons resonding to the item.

Definition at line 111 of file Start3PL.h.

References invalidLogit.

  {
    /* Compute logit of examinee proportion correct scores */
    RealVector::iterator iabil = abilities.begin();
    IE ie = begin_examinee;
    Real total = 0;
    *mean = 0.0;
    *variance = 0.0;
    for (int i = num_examinees; i--; ++ie, ++iabil)
    {
      RI resp = (*ie)->responses_begin() + item;
      Real count = (*ie)->Count();

      if (*resp != notPresentedResponse && *iabil != invalidLogit)
      {
        *mean += *iabil * count;
        *variance += *iabil * *iabil * count;
        total += count;
      }
    }

    *mean /= total;
    *variance /= total;
    *variance -= *mean * *mean;
  }

template<class V>

V etirm::ItemSubset	(	int_vector *	itemnums,
		V &	all,
		const char *	funcname
	)			[inline]

Creates a container holding the elements corresponding to a subset of items.

ItemSubset is based on a container holding elements corresponding to all items. This container is typically used to create subsets of etirmrun->items (which is an ItemVector) and etirmrun->minProc (which is a UncminVector).

Template Parameters

Parameters:

V

ItemVector type.

Function Parameters

Parameters:

[in]	*itemnums	Pointer to vector containing numbers of items to include in subset.
[in]	&all	Address of container containing all items.
[in]	*funcname	Pointer to name of calling function (used in error messages)

Definition at line 297 of file swig_etirm.h.

Referenced by etirm::estep::compute(), etirm::estep::estep(), examinee_theta_MLE(), mstep_items(), simulate_responses(), and test_characteristic_curve().

  {
    int i;
    int nsub = itemnums->size();
    int nall = all.size();

    if (nsub < 1 || nsub> nall)
    {
      throw RuntimeError("Invalid number of items", funcname);
    }

    V sub(nsub);
    int *flag = new int[nall]; // flags indicating which items are in subset
    for (i = 0; i < nall; ++i) flag[i] = 0;

    typename V::iterator iall = all.begin();
    typename V::iterator isub = sub.begin();
    int_vector::iterator ino = itemnums->begin();
    for(i = 0; i < nsub; ++i, ++isub, ++ino)
    {
      int index = *ino - 1; // elements of itemnums are 1-offset indices
      if (index < 0 || index >= nall)
      {
        delete [] flag;
        throw RuntimeError("Invalid item number", funcname);
      }
      if (flag[index] == 1)
      {
        delete [] flag;
        throw RuntimeError("Duplicate item number", funcname);
      }
      flag[index] = 1;
      *isub = iall[index];
    }
    delete [] flag;

    return sub;
  }

Here is the caller graph for this function:

double etirm::MaxRelParamDiff	(	RealVector &	oldParam,
		RealVector &	newParam,
		Real	typicalValue = 1.0
	)

Returns the maximum relative difference between an old and new set of item parameters.

Parameters:

[in]	&oldParam	Address of vector containing base parameter values.
[in]	&newParam	Address of vector containing comparison (new) parameter values.
[in]	typicalValue	Minimum denominator for relative comparison.

Definition at line 34 of file MStepIRT.cpp.

Referenced by MStepItems().

{
  double reldiff = 0.0;
  
  RealVector::iterator iold = oldParam.begin();
  RealVector::iterator inew = newParam.begin();
  
  for (int n = oldParam.size(); n--; ++iold, ++inew)
  {
    Real d = *iold - *inew;
    Real denom = *inew;
    denom = (denom < 0.0) ? -denom : denom; // fabs(denom)
    denom = (denom < typicalValue) ? typicalValue : denom;
    if (denom != 0.0) d /= denom;
    d = (d < 0.0) ? -d : d; // fabs(d)
    if (reldiff < d) reldiff = d;
  }
  
  return reldiff;
}

Here is the caller graph for this function:

double etirm::mstep_dist	(	estep *	e,
		int	group
	)

Executes M-step for the latent distribution in one group.

Returns maximum relative difference between new and old probabilities.

Function Parameters

Parameters:

[in]	*e	Pointer to not sure what(?!). To-Do: Find out what *e relates to!
[in]	group	Number of examinee group (1, 2, ..., number of groups).

Definition at line 1487 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckGroup(), CheckRunInit(), etirm::estep::GetEStep(), gEtirmRun, and etirm::SwigEtirmRun::latentDist.

  {
    CheckRunInit();
    gEtirmRun->CheckGroup(group, "mstep_dist");

    estep_type::ngroup_iterator i = (e->GetEStep())->GetNGroup(group);
    RealVector::size_type n = (e->GetEStep())->size();
    RealVector prob(i, i+n);
    return (gEtirmRun->latentDist).MStep(prob, group);
  }

Here is the call graph for this function:

int etirm::mstep_items	(	bool	ignore_max_iter,
		int_vector *	itemno
	)

CalculateS M-step for a set of items.

Function Parameters

Parameters:

[in]	ignore_max_iter	Flag: If ignore_max_iter == TRUE, then exceeding the maximum number of iterations in optimization procedure is NOT a fatal error; if ignore_max_iter == FALSE, then the exceeding the max_iter is treated as a fatal error (default = FALSE).
[in]	*itemno	Pointer to vector of integers giving item numbers (1-offset) for which the M-step is calculated. If itemno is the null pointer, then all items are used (default = null).

Definition at line 1412 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, ItemSubset(), etirm::SwigEtirmRun::minProc, MStepItems(), and etirm::SwigEtirmRun::mstepMaxDiff.

  {  // Retyped ignore_max_iter from "int" to "bool", ww, 2-25-2008.
    CheckRunInit();

    if (itemno)
    {
      const char *fname = "mstep_items";
      ItemVector itemsub = ItemSubset(itemno, gEtirmRun->items, fname);
      UncminVector minsub = ItemSubset(itemno, gEtirmRun->minProc, fname);
      return MStepItems(minsub.begin(), itemsub.begin(), itemsub.end(), gEtirmRun->mstepMaxDiff,
          ignore_max_iter);
    }
    else
    {
      return MStepItems((gEtirmRun->minProc).begin(), (gEtirmRun->items).begin(), (gEtirmRun->items).end(), gEtirmRun->mstepMaxDiff, ignore_max_iter);
    }
  }

Here is the call graph for this function:

double etirm::mstep_max_diff

(

)

Returns the maximum relative difference between parameter estimates in two successive EM iterations, as computed in last call to mstep_items.

Definition at line 1469 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::mstepMaxDiff.

  {
    CheckRunInit();

    return gEtirmRun->mstepMaxDiff;
  }

Here is the call graph for this function:

void etirm::mstep_max_iter	(	int	itemno,
		int	maxiter
	)

Assigns the maximum number of iterations permitted with optimization procedure in mstep_items for one item.

Function Parameters

Parameters:

[in]	itemno	Integer giving item number (1-offset).
[in]	maxiter	Maximum number of iterations for stepwise optimization.

Definition at line 1456 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::minProc.

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "mstep_max_iter");

    return ((gEtirmRun->minProc)[itemno-1])->SetMaxIter(maxiter);
  }

Here is the call graph for this function:

int etirm::mstep_message

(

int

itemno

)

Returns message from M-step minimization for one item.

Function Parameters

Parameters:

[in]

itemno

Integer giving item number (1-offset).

Definition at line 1438 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::CheckItemNumber(), CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::minProc.

  {
    CheckRunInit();
    gEtirmRun->CheckItemNumber(itemno, "mstep_message");

    return ((gEtirmRun->minProc)[itemno-1])->GetMessage();
  }

Here is the call graph for this function:

template<class MI, class II>

int etirm::MStepItems	(	MI	min_routines,
		II	item_begin,
		II	item_end,
		double &	maxreldiff,
		bool	ignoreMaxIter = false
	)			[inline]

Executes M-step for each item.

This function is used when the M-step can be carried out separately for each item.

Returns 0 if successful.

If ignoreMaxIter is true, and the only error that occurs is that the maximum number of M-step iterations is exceeded, then returns negative of number of items for which maximum number iterations were exceeded.

If ignoreMaxIter is false and an error occurs, or an error other than exceeding the maximum number of M-step iterations occurs, then returns the item number (1-offset) for which error occurred and processing is stopped at the point of the error.

Template Parameters

Parameters:

	II	Iterator to Item object pointer.
	MI	Iterator to pointers to minimization routines (interface is for Uncmin, but any minimization routine with the same interface as Uncmin could be used).

Function Parameters

Parameters:

[in]	min_routines	Object holding minimization routine (any minimization parameters set will be used for each item).
[in]	item_begin	Iterator pointing to first item (*item_begin is a pointer to the first item)
[in]	item_end	Iterator pointing to one past last item (*(item_end-1) is a pointer to the last item)
[out]	&maxreldiff	Address of maximum relative difference between an old and new parameter estimate across all items.
[in]	ignoreMaxIter	If true and maximum number of M-step iterations are exceeded then parameters are used anyway. If false and maximum number of M-step iterations are exceeded the function returns immediately with item number at which error occurred.

Definition at line 77 of file MStepIRT.h.

References MaxRelParamDiff().

Referenced by mstep_items().

  {
    int nMaxIter = 0;
    maxreldiff = 0.0;

    for (II iitem = item_begin; iitem != item_end; ++iitem, ++min_routines)
    {
      (*min_routines)->SetFunction(*iitem);

      int dim = (*iitem)->dim();
      RealVector start = (*iitem)->GetParameters();
      RealVector xpls(dim), gpls(dim);
      double fpls;

      int result = (*min_routines)->Minimize(start, xpls, fpls, gpls);

      if (result != 0)
      {
        int message = (*min_routines)->GetMessage();
        if (ignoreMaxIter && message == 4)
          nMaxIter--; // assumes message==4 means maximum number of iterations exceeded
        else
          return iitem-item_begin+1; // return number of item where minimization failed
      }
      (*iitem)->SetParameters(xpls);

      double d = MaxRelParamDiff(start, xpls);
      if (maxreldiff < d)
        maxreldiff = d;
    }
    return nMaxIter;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

double_vector * etirm::normal_dist_points	(	int	npoints,
		double	minPoint,
		double	maxPoint,
		double	mean,
		double	sd
	)

Returns a vector of quadrature points for a discrete distribution over a set of equally-spaced points.

Function Parameters

Parameters:

[in]	npoints	Number of discrete points in the latent distribution.
[in]	minPoint	Minimum point of the discrete distribution (must be smaller than the mean).
[in]	maxPoint	Maximum point of the discrete distribution (must be larger than the mean).
[in]	mean	Mean of the normal distribution.
[in]	sd	Standard deviation of the normal distribution.

Definition at line 1387 of file swig_etirm.cpp.

References DiscreteNormalDist().

  {
    RealVector prob(npoints);
    RealVector *points = new RealVector(npoints);

    // Probabilities do not matter so make up mean and sd
    DiscreteNormalDist(npoints, minPoint, maxPoint, points->begin(), prob.begin(), mean, sd);

    return points;
  }

Here is the call graph for this function:

double_vector * etirm::normal_dist_prob	(	int	npoints,
		double	minPoint,
		double	maxPoint,
		double	mean,
		double	sd
	)

Returns a vector of probabilities for a discrete distribution to approximate a normal distribution over a set of equally spaced points.

Note: The mean and s.d. parameters only effect the quadrature points themselves, so it does not matter which values are passed for the mean and s.d.

Function Parameters

Parameters:

[in]	npoints	Number of discrete points in the latent distribution.
[in]	minPoint	Minimum point of the discrete distribution (must be smaller than the mean).
[in]	maxPoint	Maximum point of the discrete distribution (must be larger than the mean).
[in]	mean	Mean of the normal distribution.
[in]	sd	Standard deviation of the normal distribution.

Definition at line 1364 of file swig_etirm.cpp.

References DiscreteNormalDist().

  {
    RealVector points(npoints);
    RealVector *prob = new RealVector(npoints);

    DiscreteNormalDist(npoints, minPoint, maxPoint, points.begin(), prob->begin(), mean, sd);

    return prob;
  }

Here is the call graph for this function:

int etirm::num_examinees

(

)

Returns number of examinees.

Definition at line 507 of file swig_etirm.cpp.

References CheckRunInit(), etirm::SwigEtirmRun::examinees, and gEtirmRun.

Referenced by PROX().

  {
    CheckRunInit();

    return (gEtirmRun->examinees).size();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

int etirm::num_groups

(

)

Returns number of examinee groups.

Definition at line 496 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::numGroups.

  {
    CheckRunInit();

    return gEtirmRun->numGroups;
  }

Here is the call graph for this function:

int etirm::num_items

(

)

Returns the number of items.

Definition at line 474 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::numItems.

  {
    CheckRunInit();

    return gEtirmRun->numItems;
  }

Here is the call graph for this function:

int etirm::num_latent_dist_points

(

)

Returns number of categories of the discrete theta distribution.

Definition at line 485 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::numLatentCat.

  {
    CheckRunInit();

    return gEtirmRun->numLatentCat;
  }

Here is the call graph for this function:

template<class RI, class II>

void etirm::PersonMoments	(	RI	iresp,
		II	iitem,
		RealVector &	itemdiff,
		Response	notPresentedResponse,
		Real *	mean,
		Real *	variance
	)			[inline]

Compute mean and standard deviation of logit item difficulty over items responded to by an examinee.

Template Parameters

Parameters:

	RI	Type of iterator over examinee responses (iterator returned by responses_begin() for an Examinee object)
	II	Type of iterator over items (iterator over pointers to Item objects)

Function Parameters

Parameters:

[in]	resp	Iterator pointing to first response of examinee.
[in]	iitem	Iterator pointing to first item.
[in]	itemdiff	Item difficulties.
[in]	notPresentedResponse	Response which indicates an item was not presented to an examinee. Assumed to be the same for all items.
[out]	mean	Mean of abilities for persons responding to the item.
[out]	variance	Variance of abilities for persons responding to the item.

Definition at line 65 of file Start3PL.h.

References invalidLogit.

  {

    /* Compute logit of examinee proportion correct scores */
    RealVector::iterator idiff = itemdiff.begin();
    int total = 0;
    *mean = 0.0;
    *variance = 0.0;
    for (int i = itemdiff.size(); i--; ++iitem, ++idiff)
    {
      Response resp = iresp[(*iitem)->Index()];
      if (resp != notPresentedResponse && *idiff != invalidLogit)
      {
        *mean += *idiff;
        *variance += *idiff * *idiff;
        ++total;
      }
    }

    *mean /= total;
    *variance /= total;
    *variance -= *mean * *mean;
  }

template<class EI, class RI, class II>

void etirm::PROX	(	int	numItems,
		bool	useAll,
		EI	begin_examinee,
		EI	end_examinee,
		II	begin_item,
		Response	notPresentedResponse,
		RealVector &	itemdiff,
		RealVector &	abilities
	)			[inline]

Compute Rasch item difficulties and examinee abilities using the Normal Approximation Estimation Algorithm (PROX).

The scale of the latent variable is set such that the sum of the item difficulties is zero.

For information on PROX see

Linacre, J. M. (1994). PROX with missing data. Rasch Measurement Transactions, 8(3), 378.

Cohen, L. (1979). Approximate expressions for parameter estimates in the Rasch model. British Journal of Mathematical and Statistical Psychology, 32(1), 113-120.

Template Parameters

Parameters:

	EI	Type of iterator over examinees (iterator over pointers to Examinee objects).
	RI	Type of iterator over examinee responses (iterator returned by responses_begin() for an Examinee object).
	II	Type of iterator over items (iterator over pointers to Item objects).

Function Parameters

Parameters:

[in]	numItems	Number of items.
[in]	useAll	If true calculate PROX estimates for all examinees and items, even examinees who get all items right or all items wrong, and even for items answered all correctly or all incorrectly.
[in]	begin_examinee	Iterator to pointer to first examinees.
[in]	end_examinee	Iterator to pointer to one past last examinees.
[in]	begin_item	Iterator to pointers to first item.
[in]	notPresentedResponse	Response which indicates an item was not presented to an examinee. Assumed to be the same for all items.
[out]	itemdiff	Item difficulties.
[out]	abilities	Examinee abilities.

Definition at line 176 of file Start3PL.h.

References invalidLogit, and num_examinees().

  {
    const int maxIter = 10; // maximum number of iterations for PROX algorithm
    const double convergenceCrit = 0.01; // if maximum difference in examinee abilities is less then this
    // over consecutive iterations then stop
    int i, iitem;
    int num_examinees = end_examinee - begin_examinee;
    RealVector logitDiff(numItems);
    RealVector logitAbility(num_examinees);

    /* Compute logit of item difficulties */
    RealVector::iterator ilogit = logitDiff.begin();
    for (i=0; i<numItems; ++i, ++ilogit)
    {
      Real total = 0.0;
      Real sum = 0.0;
      EI ie = begin_examinee;
      int nvalid = 0;
      iitem = begin_item[i]->Index();
      Response correct = begin_item[i]->CorrectResponse();
      while (ie != end_examinee)
      {
        RI ir = (*ie)->responses_begin() + iitem;
        if (*ir != notPresentedResponse)
        {
          if (*ir == correct)
            sum += (*ie)->Count();
          total += (*ie)->Count();
          ++nvalid;
        }
        ++ie;
      }

      if (total == 0.0)
        throw RuntimeError("No valid responses for an item", "PROX");

      if (sum == 0.0 || sum == total)
      {
        if (useAll)
        {
          Real halfCount = total / (2*nvalid); // 1/2 average count per examinee (usually 0.5)
          Real maxLogit = std::log(halfCount / (total-halfCount));

          /* Use sum = halfcount if sum == 0.0 and use sum = total - halfCount if sum == total */
          *ilogit = (sum == 0.0) ? maxLogit : (1.0 / maxLogit);
        }
        else
        {
          *ilogit = invalidLogit;
        }
      }
      else
      {
        *ilogit = std::log(sum / (total-sum));
      }
    }

    /* Compute logit of examinee proportion correct scores */
    ilogit = logitAbility.begin();
    for (EI ie = begin_examinee; ie != end_examinee; ++ie, ++ilogit)
    {
      Real total = 0.0;
      Real sum = 0.0;
      II item = begin_item;
      RI bresp = (*ie)->responses_begin();
      for (i=numItems; i--; ++item)
      {
        Response resp = bresp[(*item)->Index()];
        if (resp != notPresentedResponse)
        {
          if (resp == (*item)->CorrectResponse())
            ++sum;
          ++total;
        }
      }

      if (total == 0.0)
      {
        *ilogit = invalidLogit;
      }
      else if (sum == 0.0 || sum == total)
      {
        if (useAll)
        {
          /* Use sum = 0.5 if sum == 0.0 and use sum = total - 0.5 if sum == total */
          *ilogit = (sum == 0.0) ? (std::log(0.5 / (total-0.5))) : std::log((total - 0.5) / 0.5);
        }
        else
        {
          *ilogit = invalidLogit;
        }
      }
      else
      {
        *ilogit = std::log(sum / (total-sum));
      }
    }

    int iter;
    double mean = 0.0;
    double variance = 1.0;
    RealVector prevAbility(abilities); // ability estimates at previous iteration - used to check for convergence
    for (iter=0; iter<maxIter; ++iter)
    {
      /* Compute difficulties for each item */
      RealVector::iterator idiff = itemdiff.begin();
      ilogit = logitDiff.begin();
      Real sum = 0.0;
      int nvalid = 0;
      for (i=0; i<numItems; ++i, ++ilogit, ++idiff)
      {
        if (*ilogit != invalidLogit)
        {
          /* Compute mean and variance of abilities for persons responding to item i */
          if (iter > 0) // mean and variance of item difficulties set to 0 and 1 for first iteration
          {
            iitem = begin_item[i]->Index();
            ItemMoments<EI, RI>(num_examinees, begin_examinee, iitem, abilities,
                notPresentedResponse, &mean, &variance);
          }

          /* Compute new item difficulty */
          *idiff = mean - std::sqrt(1 + variance/2.9) * *ilogit;
          sum += *idiff;

          ++nvalid;
        }
      }

      /* adjust item difficulties to sum to zero */
      sum /= nvalid;
      idiff = itemdiff.begin();
      for (i = numItems; i--; ++idiff)
      {
        if (*idiff != invalidLogit)
          *idiff -= sum;
      }

      /* Compute abilities for each examinee */
      RealVector::iterator iabil = abilities.begin();
      ilogit = logitAbility.begin();
      for (EI ie = begin_examinee; ie != end_examinee; ++ie, ++iabil, ++ilogit)
      {
        if (*ilogit != invalidLogit)
        {
          /* Compute mean and variance of item difficulties for items person responded to */
          PersonMoments<RI, II>((*ie)->responses_begin(), begin_item, itemdiff, notPresentedResponse, &mean, &variance);

          /* Compute new person ability */
          *iabil = mean + std::sqrt(1 + variance/2.9) * *ilogit;
        }
      }

      /* Check if abilities have converged */
      if (iter > 0)
      {
        Real maxdiff = 0.0;
        for (i=0; i<num_examinees; ++i)
        {
          if (abilities[i] != invalidLogit)
          {
            Real diff = std::fabs(abilities[i] - prevAbility[i]);
            if (diff > maxdiff)
              maxdiff = diff;
          }
        }
        if (maxdiff < convergenceCrit)
          break;
      }
      prevAbility = abilities;
    }
  }

Here is the call graph for this function:

char etirm::Resp2Char	(	Response	r,
		const item_type *	item
	)

Converts a response for an item into a character, where '0' represents the first response, '1' represents the second response, etc.

If the number of response categories for the item is greater than 10, then the characters returned will be ascii characters greater than '9'. For example, a ':' is return for a response in response category 11, since ':' is one greater than '9' in the ascii sequence.

Function Parameters

Parameters:

[in]	r	Item response to be converted.
[in]	*item	Pointer to item object.

Definition at line 354 of file swig_etirm.cpp.

References etirm::Item< L >::FirstResponse(), etirm::Item< D::latentvar_type >::NotPresentedResponse(), and etirm::Item< L >::ResponseIndex().

Referenced by examinee_response_str().

  {
    const char zero = '0';
    Response np = item_type::NotPresentedResponse();
    char cr;
    if (r == np)
      cr = np - item->FirstResponse() + zero;
    else
      cr = item->ResponseIndex(r) + zero;

    return cr;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void etirm::set_missing_resp

(

char

nr

)

Assigns missing response code to identify examinees who did not respond to an item.

Definition at line 461 of file swig_etirm.cpp.

References gEtirmRun.

  {
    if (gEtirmRun)
    {
      throw RuntimeError("The not presented response can only be set before any items are initialized", 0);
    }
    Item<Real>::SetNotPresentedResponse(nr);
  }

const char * etirm::simulate_response_str	(	double	theta,
		int_vector *	itemno2
	)

Simulates item responses (characters) for a specific value of the latent variable.

Returns simulated responses in a string, where each character of the string gives a response to one item. The first response category of an item is represented by a '0', the second response category by a '1', etc.

Because each response is represented by a single character care must be taken when some items have more than 10 response categories. For example, a response in the 11th response category would be represented by the ascii character ':', which is the 10th character greater than '0' in the ascii character sequence.

Function Parameters

Parameters:

[in]	theta	Value of latent variable for which item responses are generated.
[in]	itemno2	List of item numbers of the items for which responses will be simulated.

Definition at line 2055 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, etirm::Item< D::latentvar_type >::NotPresentedResponse(), etirm::SwigEtirmRun::returnString, and simulate_responses().

  {
    CheckRunInit();

    // Vector of integers representing simulated responses
    int_vector *iresp = simulate_responses(theta, itemno2);

    // Resize string to contain item responses
    std::string &responseStr = gEtirmRun->returnString;
    responseStr.resize(iresp->size());

    // Convert integers to characters
    int_vector::iterator ii = iresp->begin();
    std::string::iterator ic = responseStr.begin();
    for (int i = iresp->size(); i--; ++ii, ++ic)
    {
      if (*ii < 0)
      {
        *ic = item_type::NotPresentedResponse();
      }
      else
      {
        *ic = *ii + '0';
      }
    }

    delete iresp;

    return responseStr.c_str();
  }

Here is the call graph for this function:

int_vector * etirm::simulate_responses	(	double	theta,
		int_vector *	itemno2
	)

Simulates item responses (integers) for a specific value of the latent variable.

Returns pointer to integer vector containing item responses, where item responses are integers from 0 to one minus the maximum number of response categories for the item.

Function Parameters

Parameters:

[in]	theta	Value of latent variable for which item responses are generated.
[in]	itemno2	List of item numbers of the items for which responses will be simulated.

Definition at line 2008 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::base_rand_simulate, CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, ItemSubset(), etirm::SwigEtirmRun::rand_simulate, and SimulateResponses().

Referenced by simulate_response_str().

  {
    CheckRunInit();

    if (!gEtirmRun->base_rand_simulate)
    {
      gEtirmRun->base_rand_simulate = new random_type();
      gEtirmRun->rand_simulate = new boost::uniform_01<random_type>(*(gEtirmRun->base_rand_simulate));
    }

    int_vector *resp;
    if (itemno2)
    {
      resp = new int_vector(itemno2->size());
      ItemVector sitems = ItemSubset(itemno2, gEtirmRun->items, "simulate_responses");
      resp->newsize(sitems.size());
      SimulateResponses(sitems.begin(), sitems.end(), theta, *(gEtirmRun->rand_simulate),
          resp->begin(), true);
    }
    else
    {
      resp = new int_vector((gEtirmRun->items).size());
      SimulateResponses((gEtirmRun->items).begin(), (gEtirmRun->items).end(), theta, *(gEtirmRun->rand_simulate), resp->begin(), true);
    }

    return resp;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void etirm::simulate_seed

(

unsigned long

seed

)

Assigns seed of random number generator used for simulating item responses.

Function Parameters

Parameters:

[in]

seed

Seed value, 0 <= seed <= 4,294,967,295.

Definition at line 1976 of file swig_etirm.cpp.

References etirm::SwigEtirmRun::base_rand_simulate, CheckRunInit(), gEtirmRun, and etirm::SwigEtirmRun::rand_simulate.

  {
    CheckRunInit();

    // convert to type used for seed in boost random number library
    boost::uint32_t boost_seed = seed;

    if (gEtirmRun->base_rand_simulate)
    {
      gEtirmRun->base_rand_simulate->seed(boost_seed);
    }
    else
    {
      gEtirmRun->base_rand_simulate = new random_type(boost_seed);
      gEtirmRun->rand_simulate = new boost::uniform_01<random_type>(*(gEtirmRun->base_rand_simulate));
    }
  }

Here is the call graph for this function:

template<class II, class T, class R, class RI>

void etirm::SimulateResponses	(	II	item_begin,
		II	item_end,
		T &	theta,
		R &	rand,
		RI	iresp,
		bool	resp_indices = false
	)			[inline]

Simulate responses to a set of items for a specific latent variable value.

Template Parameters

Parameters:

	II	Type of iterator over items (iterator over pointers to Item objects)
	T	Type of latent variable.
	R	Type of function object for generating random numbers in the interval (0,1).
	RI	Type of iterator over responses.

Function Parameters

Parameters:

[in]	item_begin	Iterator pointing to first item.
[in]	item_end	Iterator pointing to one past last item.
[in]	&theta	Value of latent variable for which response will be generated.
[in]	&rand	Uniform (0,1) random number generator.
[out]	iresp	Iterator pointing to first response to be generated.
[in]	resp_indices	- If true generate integer response indices, rather than responses of type Response, The integer index for the first response category is zero, the integer index for the second response category is is one, etc. If true then the type RI must be an interator over a container of integers, otherwise RI should be an interator over a container of type Response.

Definition at line 55 of file SimulateResponses.h.

Referenced by simulate_responses().

  {
    std::vector<Real> prob;
    for (; item_begin != item_end; ++item_begin, ++iresp)
    {
      int ncat = (*item_begin)->NumRespCat();
      prob.resize(ncat);
      (*item_begin)->ProbRespAll(theta, prob.begin());

      // compute cumulative probabilities
      std::vector<Real>::iterator ip = prob.begin()+1;
      int i = ncat - 2;
      while (i--)
      {
        *ip += ip[-1];
        ++ip;
      }
      *ip = 1.0; // last cumulative probability should be 1

      // Generate response by finding first cumulative probability
      // greater than a random number
      Real r = rand();
      i = 0;
      ip = prob.begin();
      while (*ip <= r)
      {
        ++ip;
        ++i;
      }

      *iresp = (resp_indices) ? i : (*item_begin)->IndexResponse(i);
    }
  }

Here is the caller graph for this function:

template<class RI, class MI, class EI, class I, class II>

int etirm::StartingValues3PL	(	MI	begin_min,
		EI	begin_examinee,
		EI	end_examinee,
		II	begin_item,
		II	end_item,
		Response	notPresentedResponse,
		bool	useAll = false,
		int	baseGroup = 1,
		std::set< I * > *	calc_items = 0
	)			[inline]

Computes starting values for a sequence of items modeled with the three-parameter logistic model.

Nonlinear regression is employed for each item, treating the theta estimate for each person as the independent variable and the item responses as the dependent variable. Theta estimates and initial b parameters for the nonlinear regression are calculated using the PROX procedure. Theta estimates for each person are categorized using latent variable categories defined for each item (using the interface of class ItemNR).

Returns the number of times minimization procedure failed while using nonlinear regression. Nonconvergence after the maximum number of iterations has been exceeded is not considered a failure.

Template Parameters

Parameters:

	RI	Type of iterator over examinee responses (iterator returned by responses_begin() for an Examinee object).
	MI	Type of iterator over minimization routines used for each item.
	EI	Type of iterator over examinees (iterator over pointers to Examinee objects).
	I	Item type.
	II	Type of iterator over items (iterator over pointers to Item objects).

Function Parameters

Parameters:

[in]	begin_min	Iterator to pointers to minimization routines used for items. These should correspond to the items given by begin_item and end_item that are in the set calc_items.
[in]	begin_examinee	Iterator to pointer to the first examinee.
[in]	end_examinee	Iterator to pointer to one past the last examinee.
[in,out]	begin_item	Iterator to pointer to the first item.
[in,out]	end_item	Iterator to pointer to one past the last item. All these items are used in computing PROX estimates of examinee abilities. Starting values are computed for any of these items that are also in the set calc_items. On output the item parameter estimates for each item also present in calc_items are set to the starting values calculated in this function.
[in]	notPresentedResponse	Response which indicates an item was not presented to an examinee. Assumed to be the same for all items.
[in]	useAll	If true calculate PROX estimates for all examinees and items, even examinees who get all items right or all items wrong, and even for items answered all correctly or all incorrectly.
[in]	baseGroup	Number of group to use as base group where mean and s.d. of latent variable distribution are zero and one.
[in]	calc_items	Set containing items for which starting values are computed. All items given by begin_item and end_item are used to compute PROX estimates of examinee ability, but starting values are only calculated for items in calc_items. If calc_items is null then starting values are computed for all items given by begin_item and end_item.

Definition at line 467 of file Start3PL.h.

References invalidLogit.

  {

    int numExaminees = end_examinee - begin_examinee;
    int numItems = end_item - begin_item;

    RealVector thetas(numExaminees, invalidLogit);
    RealVector itemDiff(numItems, invalidLogit);

    typedef std::vector<Response> cvector;

    /* Compute PROX estimates of examinee ability and item difficulty */
    PROX<EI, RI, II>(numItems, useAll, begin_examinee, end_examinee, begin_item,
        notPresentedResponse, itemDiff, thetas);

    /* Compute mean of PROX estimates of examinee ability in base group and assign case weights */
    int i;
    RealVector nVec(numExaminees); // store case weights to use in regression
    RealVector::iterator in = nVec.begin();
    RealVector::iterator itheta = thetas.begin();
    Real mean = 0.0;
    Real nwt = 0.0;
    EI ie = begin_examinee;
    for (i = numExaminees; i--; ++in, ++itheta, ++ie)
    {
      *in = (*ie)->Count();
      if ((*ie)->Group() == baseGroup && *itheta != invalidLogit)
      {
        mean += *itheta * *in;
        nwt += *in;
      }
    }
    if (nwt == 0)
      throw RuntimeError("No examinees with valid item responses in base group",
          "StartingValues3PL");

    mean /= nwt;

    /* Compute standard deviation of PROX estimates of examinee ability in base group */
    Real sd = 0.0;
    itheta = thetas.begin();
    in = nVec.begin();
    ie = begin_examinee;
    for (i = numExaminees; i--; ++in, ++itheta, ++ie)
    {
      if ((*ie)->Group() == baseGroup && *itheta != invalidLogit)
      {
        Real diff = *itheta - mean;
        sd += diff * diff * *in;
      }
    }
    sd /= nwt;
    sd = std::sqrt(sd);

    /* Put thetas on latent variable scale so mean and s.d. of thetas for examinees in base group are 0 and 1 */
    itheta = thetas.begin();
    for (i=numExaminees; i--; ++itheta)
    {
      if (*itheta != invalidLogit)
      {
        *itheta -= mean;
        *itheta /= sd;
      }
    }

    /* Put b parameters on latent variable scale so mean and s.d. of thetas for examinees in base group are 0 and 1 */
    RealVector::iterator idiff = itemDiff.begin();
    for (i = numItems; i--; ++idiff)
    {
      if (*idiff != invalidLogit)
      {
        *idiff -= mean;
        *idiff /= sd;
      }
    }

    RealVector itemTheta(numExaminees); // vector of thetas for examinees who reponded to an item
    RealVector rVec(numExaminees); // count of number of correct answers for each theta value 
    // (r vector in M-step computation)
    // nVec holds count for each theta value (n vector in M-step computation)

    /* Compute starting values for each item */
    int minError = 0; // Count of number of time minimization failed in computing regression
    for (int item = 0; item < numItems; ++item, ++begin_item)
    {
      if (calc_items)
      {
        if (calc_items->find(*begin_item) == calc_items->end())
          continue;
      }

      /* Create vectors of item responses and thetas for item */
      EI ie = begin_examinee;
      RealVector::iterator it = itemTheta.begin();
      in = nVec.begin();
      RealVector::iterator ir = rVec.begin();
      RealVector::iterator alltheta = thetas.begin();
      int n = 0; // number of examinees who respond to the item
      nwt = 0.0; // weighted number of examinees who respond to the item
      Real pvalue = 0.0;
      Response correct = (*begin_item)->CorrectResponse();
      while (ie != end_examinee)
      {
        RI iresp = (*ie)->responses_begin() + (*begin_item)->Index();
        if (*iresp != notPresentedResponse && *alltheta != invalidLogit)
        {
          *it = *alltheta;
          *in = (*ie)->Count();
          nwt += *in;
          if (*iresp == correct)
          {
            pvalue += *in;
            *ir = *in;
          }
          else
          {
            *ir = 0.0;
          }
          ++n;
          ++it;
          ++in;
          ++ir;
        }
        ++alltheta;

        ++ie;
      }
      pvalue /= nwt;

      /* Compute starting values for item */
      int numParameters = (*begin_item)->NumParameters();
      RealVector start(numParameters);
      Real startb = itemDiff[item]; // use b from PROX as starting value

      if (numParameters > 1)
      {
        // PROX estimate assumes D=1.0, so if D for item is different from
        // 1.0 adjust the a-parameter.
        start(1) = 1.0 / (*begin_item)->NormalizingConstant();
        start(2) = startb;
      }
      else
      {
        start(1) = startb;
      }

      /* Make starting c parameter slightly larger than zero since prior density of c
       is zero when c is equal to zero */
      if (numParameters > 2)
        start(3) = 0.05;

      if (pvalue == 1.0 || pvalue == 0.0)
      {
        if (!useAll)
        {
          /* If all responses to an item are correct or incorrect and useAll is false then PROX
           estimate of b will not exist, so use logit of number correct score 1/2 different from zero
           or perfect as b starting value. */
          Real maxlogit = std::log((numExaminees - 0.5) / 0.5);
          startb = (pvalue == 1.0) ? maxlogit : 1.0/maxlogit;
          if (numParameters > 1)
            start(2) = startb;
          else
            start(1) = startb;
        }
        (*begin_item)->NonZeroPriors(start);
        (*begin_item)->SetParameters(start);
      }
      else
      {
        /* Use nonlinear regression to find starting values */

        /* Assign expected counts n and r for item */
        AssignItemNR<I>(n, itemTheta.begin(), nVec.begin(), rVec.begin(), *begin_item);

        (*begin_min)->SetFunction(*begin_item);

        RealVector xpls(numParameters), gpls(numParameters);
        double fpls;

        /* Modify starting values which for which prior density is zero */
        (*begin_item)->NonZeroPriors(start);

        int result = (*begin_min)->Minimize(start, xpls, fpls, gpls);

        // assign values computed if minimization succeeded 
        // or failed because of the maximum number of iterations
        // being exceeded without convergence
        if (!result || (*begin_min)->GetMessage() == 4)
        {
          (*begin_item)->SetParameters(xpls);
        }
        else // if minimization failed use initial starting value for b
        {
          start(1) = 1.0;
          start(3) = 0.1;
          (*begin_item)->SetParameters(start);
          minError++;
        }
      }
      ++begin_min; // only increment for items for which starting values are computed
    }
    return minError;
  }

double_vector * etirm::test_characteristic_curve	(	double_vector *	thetas,
		int_vector *	ilist2
	)

Returns a vector of values of the test characteristic curve, given a vector of theta values and a selection of items.

It is assumed for each item that the lowest response category corresponds to a score of 0, the second response category corresponds to a score of 1, etc.

Function Parameters

Parameters:

[in]	*thetas	Pointer to vector of theta values.
[in]	*ilist2	Pointer to vector of item sequence numbers (1-based).

Definition at line 993 of file swig_etirm.cpp.

References CheckRunInit(), gEtirmRun, etirm::SwigEtirmRun::items, and ItemSubset().

  {
    CheckRunInit();

    double_vector tcc(thetas->size(), 0.0);

    // Vector to hold response probabilities for an item.
    double_vector probs;

    ItemVector *sitems;
    if (ilist2)
    {
      sitems = new ItemVector(ItemSubset(ilist2, gEtirmRun->items, "test_characteristic_curve"));
    }
    else
    {
      sitems = &(gEtirmRun->items);
    }

    // loop over items
    ItemVector::iterator ii = sitems->begin();
    for (int i = sitems->size(); i--; ++ii)
    {
      int ncat = (*ii)->NumRespCat();
      probs.newsize(ncat);

      double_vector::iterator icc = tcc.begin();
      double_vector::iterator it = thetas->begin();
      for (int j = tcc.size(); j--; ++icc, ++it) // loop over thetas
      {
        (*ii)->ProbRespAll(*it, probs.begin());

        // first response category corresponds to 0, second response category
        // corresponds to 1, etc.
        double dresp = 1.0; // Start with response 1, 0 is skipped
        double sum = 0.0;
        double_vector::iterator ip = probs.begin()+1;
        for (int k = ncat-1; k--; ++ip, ++dresp)
        {
          sum += dresp * *ip;
        }

        // Add expected score for item to TCC
        *icc += sum;
      }
    }

    if (ilist2)
      delete sitems;

    return new double_vector(tcc);
  }

Here is the call graph for this function:

---

Variable Documentation

SwigEtirmRun* etirm::gEtirmRun = 0

Global variable holding information about a run.

Definition at line 108 of file swig_etirm.cpp.

Referenced by add_examinee(), bootstrap_sample(), bootstrap_seed(), etirm::SwigEtirmRun::CheckExamineeNumber(), etirm::SwigEtirmRun::CheckExaminees(), etirm::SwigEtirmRun::CheckGroup(), etirm::SwigEtirmRun::CheckItemNumber(), CheckItemParam(), etirm::estep::compute(), dist_get_point(), dist_get_points(), dist_get_prob(), dist_get_probs(), dist_mean_sd(), dist_scale(), dist_set_point(), dist_set_points(), dist_set_prob(), dist_set_probs(), dist_transform(), dist_unique_points(), etirm::estep::estep(), examinee_get_count(), examinee_get_group(), examinee_get_posterior(), examinee_posterior_mean(), examinee_response_str(), examinee_responses(), examinee_set_count(), examinee_set_group(), examinee_set_posterior(), examinee_theta_MLE(), examinees_count(), get_responses(), get_responses_missing(), item_cat_counts(), item_get_all_params(), item_get_model(), item_get_param(), item_get_params(), item_get_prior_param(), item_get_prior_type(), item_num_params(), item_num_resp_cat(), item_prob_resp(), item_resp_count(), item_scale_params(), item_set_all_params(), item_set_param(), item_set_params(), item_set_prior(), mstep_dist(), mstep_items(), mstep_max_diff(), mstep_max_iter(), mstep_message(), num_examinees(), num_groups(), num_items(), num_latent_dist_points(), set_missing_resp(), simulate_response_str(), simulate_responses(), simulate_seed(), and test_characteristic_curve().

const Real etirm::invalidLogit = 10000.0

value to indicate invalid logit (e.g., logit(1))

Definition at line 41 of file Start3PL.h.

Referenced by ItemMoments(), PersonMoments(), PROX(), and StartingValues3PL().

const double etirm::logZero = -1021.0

Value used to represent the log of zero probabilities.

Definition at line 56 of file EStepDiscrete.h.

Referenced by etirm::EStepDiscrete< E, I, II, D >::DoEStep(), etirm::EStepDiscrete< E, I, II, D >::EStepDiscrete(), and etirm::EStepDiscrete< E, I, II, D >::ExamineePosterior().

---