void OnePLACModel::successProbability(DimensionModel *dimensionModel, QuadratureNodes * quadNodes)
{
int q = 0;
double a_d, d_d, theta_d; // d stands from "double"
if (dimensionModel != NULL)
q = quadNodes->size();
if (typeid(*dimensionModel) == typeid(UnidimensionalModel))
{
if (probabilityMatrix == NULL)
//Creates the matrix if it is not already created
probabilityMatrix = new Matrix<double>(q, items);
a_d = parameterSet[0][0][0];
for (int k = 0; k < q; k++)
{
for (int i = 0; i < items; i++)
{
theta_d = (*quadNodes->getTheta())(0, k);
d_d = parameterSet[1][0][i];
(*probabilityMatrix)(k, i) = successProbability(theta_d, a_d, d_d);
}
}
}
}
void OnePLACModel::gradient(double* args, double* pars, int nargs, int npars, double* gradient)
{
int nA = 0;
int nP = 0;
int q, items;
double *theta, *r, *f, *a, *d;
double sumTA = 0.0;
double sumTBs = 0.0;
double aux;
// Obtain q
q = pars[nP++]; // q is obtained and npars is augmented
// Obtain I
items = pars[nP++];
theta = new double[q];
r = new double[q * items];
f = new double[q];
a = new double[1];
d = new double[items];
// Obtain theta
for (int k = 0; k < q; k++)
theta[k] = pars[nP++];
// Obtain f
for (int k = 0; k < q; k++)
f[k] = pars[nP++];
// Obtain r
for (int k = 0; k < q; k++)
for (int i = 0; i < items; i++)
r[k * items + i] = pars[nP++];
// Obtain a
a[0] = args[nA++];
// Obtain d
for (int i = 0; i < items; i++)
d[i] = args[nA++];
for (int i = 0; i < items; i++)
{
sumTBs = 0.0;
for (int k = 0; k < q; k++)
{
aux = (r[k * items + i] - f[k] * successProbability(theta[k], a[0], d[i]));
sumTBs += aux;
sumTA += theta[k] * aux;
}
gradient[1 + i] = -sumTBs;
}
gradient[0] = -sumTA;
delete[] theta;
delete[] r;
delete[] f;
delete[] a;
delete[] d;
}
double ThreePLModel::successProbability_cPrime(double theta, double a, double b, double c)
{
long double cPrime = exp(c)/(1+exp(c));
return (successProbability ( theta, a, b, cPrime ));
}
//remember that model class wraps this so only quad nodes is needed to call this.
void ThreePLModel::successProbability(DimensionModel *dimensionModel, QuadratureNodes * quadNodes)
{
int q = 0;
double a_d, d_d, c_d, theta_d; // d stands from "double"
if ( dimensionModel != NULL )
q = quadNodes->size();
if(typeid(*dimensionModel)==typeid(UnidimensionalModel))
{
if(probabilityMatrix == NULL)
//Creates the matrix if it is not already created
probabilityMatrix = new Matrix<double>(q,items);
for (int k = 0; k < q; k++)
{
for (int i = 0; i < items; i++ )
{
// 3PL Success Probability Function
theta_d = (*quadNodes->getTheta())(0,k);
a_d = parameterSet[0][0][i];
d_d = parameterSet[1][0][i];
c_d = parameterSet[2][0][i];
(*probabilityMatrix)(k,i) = successProbability ( theta_d, a_d, d_d, c_d );
}
}
}
if(typeid(*dimensionModel)==typeid(MultidimensionalModel))
{
int dims = dimensionModel->getNumDimensions();
int totalNodes = pow(q,dims);
if(probabilityMatrix == NULL)
{
//Creates the matrix if it is not already created
//This matrix has many more columns because in the multidim case it stores
probabilityMatrix = new Matrix<double>(totalNodes,items);
}
//Filling the matrix
//Perform times selections in
//LEAKS
double * theta = new double[dims];
int * theta_index = new int[dims];
if(multiweights == NULL){
//cout<<"MU WEIS IS NULL"<<endl;
multiweights = new double[totalNodes];
}
for (int k = 0; k < totalNodes; k++) {
multiweights[k] = 1;
}
for (int k = 0; k < dims; k++) {
theta_index[k] = 0;
}
for (int k = 0; k < totalNodes; k++) {
//Calculate theta index
fullpermutations(dims,q,k,theta_index);
//Index the theta array at the theta_index
for (int j = 0; j < dims; j++) {
theta[j] = (*quadNodes->getTheta())(0,theta_index[j]);
multiweights[k] *= (*quadNodes->getWeight())(0,theta_index[j]);
}
//Now calculate the probability for each item using the theta array.
// a alias : parameterSet[0][0] *
//std::cout << "Must enter the universe" << std::endl;
for (int i = 0; i < items; i++ )
{
// 3PL Success Probability Function
d_d = parameterSet[1][0][i];
c_d = parameterSet[2][0][i];
//std::cout<<"d : "<< d_d << "th : "<< theta[0]<<" "<< theta[1]<<" "<<std::endl;
(*probabilityMatrix)(k,i) = successProbabilityMD ( theta,
parameterSet[0][0]+(dims*i) //This is a array passed directly
, d_d, c_d , dims );
}
}
delete [] theta;
delete [] theta_index;
}
}
void ThreePLModel::itemGradient(double* args, double* pars, int nargs, int npars, double* gradient)
{
int nP, q, items, index;
double a, b, c;
double D = Constant::NORM_CONST;
double *theta, *r, *f;
long double *h_0; // Block Matrix of size q*I. Each block-element has size of 1*3
long double *h; // Block vector of size I (i.e. I blocks). Each block-element has size of 1*3
long double *P_Star, *P; // Matrix of size q*I
long double *W; // Matrix of size q*I
long double *factor; // Matrix of product (r-fP)W
long double ec; // e^c_i
long double ecp1i; // 1 / (e^c_i + 1)
index = pars[npars-1];
nP = 0;
a = args[0];
b = args[1];
c = args[2];
q = pars[nP ++];
items = pars[nP ++];
theta = new double[q];
r = new double[q];
f = new double[q];
h = new long double [3];
h_0 = new long double [q*3];
P = new long double [q];
P_Star = new long double [q];
factor = new long double [q];
W = new long double [q];
// Obtain theta
for (int k=0; k<q; k++)
theta[k] = pars[nP ++];
// Obtain f
for (int k=0; k<q; k++)
f[k] = pars[nP ++];
// Obtain r that becomes a vector
for (int k=0; k<q; k++)
{
nP += index;
r[k] = pars[nP];
nP += (items-index);
}
ecp1i=1/(1+exp(c));
ec=exp(c);
for ( int k = 0; k < q; k++ )
{
P[k] = successProbability ( theta[k], a,b,c);
P_Star[k] = 1/(1+exp(-D*(a*theta[k]+b)));
W[k] = P_Star[k] * ( 1 - P_Star[k] ); // Numerator
W[k] /= P[k] * ( 1 - P[k] );// Denominator
factor[k] = ( r[k] - f[k]*P[k] ) * W[k];
// h_0 / (P_star*Q_star)
h_0[3 * k ] = D * theta[k] * ecp1i;
h_0[3 * k + 1] = D * ecp1i;
h_0[3 * k + 2] = ec * (ecp1i*ecp1i) / P_Star[k];
}
memset(h,0,sizeof(long double)*3);
memset(gradient,0,sizeof(double)*3);
for ( int k = 0; k < q; k++ )
{
h[0] += factor[k] * h_0[3 * k + 0];
h[1] += factor[k] * h_0[3 * k + 1];
h[2] += factor[k] * h_0[3 * k + 2];
}
delete [] h_0;
delete [] P_Star;
delete [] P;
delete [] W;
delete [] factor;
delete [] theta;
delete [] r;
delete [] f;
//return h as the gradient
int hc=0;
for (int n = 0; n < 3; ++n)
gradient[hc++]= -static_cast<double>(h[n]);
delete [] h;
}
double ThreePLModel::successProbability(double theta, double * zita) { return successProbability(theta, zita[0], zita[1], zita[2]); }
void TwoPLModel::itemGradient (double* args, double* pars, int nargs, int npars, double* gradient)
{
int nP, q, items, index, hc;
double *theta, *r, *f;
double a, b, D;
double *h_0; // Block Matrix of size q*I. Each block-element has size of 1*2
double *h; // Block vector of size I (i.e. I blocks). Each block-element has size of 1*2
double *P; // Matrix of size q*I
double *factor; // Matrix of product (r-fP)W
index = pars[npars-1];
hc = nP = 0;
D = Constant::NORM_CONST;
a = args[0];
b = args[1];
q = pars[nP ++];
items = pars[nP ++];
theta = new double[q];
r = new double[q];
f = new double[q];
h = new double [2];
h_0 = new double [q*2];
P = new double [q];
factor = new double [q];
// Obtain theta
for (int k=0; k<q; k++)
theta[k] = pars[nP ++];
// Obtain f
for (int k=0; k<q; k++)
f[k] = pars[nP ++];
// Obtain r that becomes a vector
for (int k=0; k<q; k++)
{
nP += index;
r[k] = pars[nP];
nP += (items-index);
}
for ( int k = 0; k < q; k++ )
{
P[k] = successProbability ( theta[k], a,b);
factor[k] = ( r[k] - f[k]*P[k] );
h_0[2 * k ] = D * theta[k];
h_0[2 * k + 1] = D;
}
memset(h,0,sizeof(double)*2);
memset(gradient,0,sizeof(double)*2);
for ( int k = 0; k < q; k++ )
{
h[0] += factor[k] * h_0[2 * k + 0];
h[1] += factor[k] * h_0[2 * k + 1];
}
delete [] h_0;
delete [] P;
delete [] factor;
delete [] theta;
delete [] r;
delete [] f;
//return h as the gradient
for (int n = 0; n < 2; ++n)
gradient[hc++]= -static_cast<double>(h[n]);
delete [] h;
}
inline double TwoPLModel::successProbability(double theta, double * zita) { return successProbability(theta, zita[0], zita[1]); }
