public void test_NextItem_P(int numofItems, ModelNames.Models paramModel, ModelNames.CriterionTypes paramCriterion)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + numofItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
// Call "NextItem" function from R
GenericVector r_NextItem = engineObj.Evaluate("r_NextItem <- nextItem(PolyItems, model = modelName, theta = 0, criterion = \"" + paramCriterion.ToString() + "\")").AsList();
// Selected item
NumericVector item = r_NextItem[0].AsNumeric();
DataFrame par = r_NextItem[1].AsDataFrame();
// Value of "info"
NumericVector thStart = r_NextItem[2].AsNumeric();
// Criterion
CharacterVector startSelect = r_NextItem[3].AsCharacter();
// Call "NextItem" function from CS
NextItemModel cs_NextItem = CatRLib.NextItem(itemBank, model: paramModel.EnumToString(), theta: 0, criterion: (int)paramCriterion);
//Test passed for "MFI"
if (item[0] != cs_NextItem.item)
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
public void testKL_D(int NumOfItems)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + NumOfItems + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Length, false);
// New Dictionary
itemBank.SetItemParamter(CATItems.ColumnNames.a, DichoItems[0].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.b, DichoItems[1].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.c, DichoItems[2].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.d, DichoItems[3].Select(y => (double)y).ToArray());
// Dichotomous Items
DataFrame it_given_R = engineObj.Evaluate("it_given_R <- DichoItems[c(4, 8),]").AsDataFrame();
engineObj.SetSymbol("it_given_R", it_given_R);
CATItems it_given = itemBank.FindItem(new int[] { 4, 8 });
//Creation of a response pattern
NumericVector x_val = engineObj.Evaluate("x_val <- c(0, 1)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = new int[] { 0, 1 };
// Call "thetaEST" function from R, method = \"ML\"
NumericVector Theta = engineObj.Evaluate("Theta <- thetaEst(it_given_R, x_val, method = \"ML\")").AsNumeric();
// Call "KL" function from R
NumericVector r_KL = engineObj.Evaluate("r_KL <- KL(DichoItems, 1, x_val, it_given_R, theta = Theta)").AsNumeric();
// Call "thetaEST" function from CS
double th = CatRLib.ThetaEst(it_given, x, "", method: "ML");
// Call "KL" function from CS
double cs_KL = CatRLib.KL(itemBank, 1, x, it_given, "", theta: th);
if (r_KL[0] - cs_KL > testEpsilon)
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
public void test_MWI_D(int NumOfItems)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + NumOfItems + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Length, false);
// New Dictionary
itemBank.SetItemParamter(CATItems.ColumnNames.a, DichoItems[0].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.b, DichoItems[1].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.c, DichoItems[2].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.d, DichoItems[3].Select(y => (double)y).ToArray());
// Dichotomous Items
DataFrame it_given_R = engineObj.Evaluate("it_given_R <- DichoItems[c(4, 8),]").AsDataFrame();
engineObj.SetSymbol("it_given_R", it_given_R);
//Creation of a response pattern for theta value
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(0, it_given_R)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
CATItems it_given = itemBank.FindItem(new int[] { 4, 8 });
// Call "MWI" function from R
NumericVector r_mwi = engineObj.Evaluate("r_mei <- MWI(DichoItems, 1, x_val, it_given_R, type = \"MPWI\")").AsNumeric();
// Call "MWI" function from CatRCS
double cs_mwi = CatRLib.MWI(itemBank, 1, x, it_given, "", 2);
if (r_mwi[0] - cs_mwi > testEpsilon)
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
public void testIntegrateCatR()
{
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
//Sequence generation
NumericVector x = engineObj.Evaluate("x <- seq(from = -4, to = 4, length = 33)").AsNumeric();
engineObj.SetSymbol("x", x);
double[] x_val = x.Select(p => (double)p).ToArray();
NumericVector y = engineObj.Evaluate("y <- exp(x)").AsNumeric();
engineObj.SetSymbol("y", y);
double[] y_val = y.Select(p => (double)p).ToArray();
// Call function from R
NumericVector result_Integrate = engineObj.Evaluate("result_Integrate <- integrate.catR(x, y)").AsNumeric();
engineObj.SetSymbol("result_Integrate", result_Integrate);
// Call function from inside
double result = CatRLib.Integrate_catR(x_val, y_val);
decimal temp1 = decimal.Round(Convert.ToDecimal(result_Integrate[0]), 4);
decimal temp2 = decimal.Round(Convert.ToDecimal(result), 4);
decimal errFraction = 0;
if (temp1 > temp2)
{
errFraction = temp1 - temp2;
}
else if (temp2 > temp1)
{
errFraction = temp2 - temp1;
}
else
{
Assert.AreEqual(temp1, temp2);
}
}
public void test_StartItems_D(int numofItems)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + numofItems + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Length, false);
// New Dictionary
itemBank.SetItemParamter(CATItems.ColumnNames.a, DichoItems[0].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.b, DichoItems[1].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.c, DichoItems[2].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.d, DichoItems[3].Select(y => (double)y).ToArray());
// Call "StartItems" function from R, "MFI" criterion
GenericVector r_StartItems = engineObj.Evaluate("r_StartItems <- startItems(DichoItems, nrItems = 3, theta = 1, halfRange = 2)").AsList();
// Resulting item numbers
IntegerVector items = r_StartItems[0].AsInteger();
DataFrame tempitems = r_StartItems[1].AsDataFrame();
// Resulting Items
CATItems r_CatItems = new CATItems(tempitems[0].Length, false);
r_CatItems.SetItemParamter(CATItems.ColumnNames.a, tempitems[0].Select(y => (double)y).ToArray());
r_CatItems.SetItemParamter(CATItems.ColumnNames.b, tempitems[1].Select(y => (double)y).ToArray());
r_CatItems.SetItemParamter(CATItems.ColumnNames.c, tempitems[2].Select(y => (double)y).ToArray());
r_CatItems.SetItemParamter(CATItems.ColumnNames.d, tempitems[3].Select(y => (double)y).ToArray());
// Ability value
NumericVector thStart = r_StartItems[2].AsNumeric();
// Criterion
CharacterVector startSelect = r_StartItems[3].AsCharacter();
// Call "StartItems" function from CS
StartItemsModel cs_StartItems = CatRLib.StartItems(itemBank, nrItems: 3, theta: 1, halfRange: 2);
// Check selected items
if (items.Length == cs_StartItems.items.Length)
{
for (int ind = 0; ind < cs_StartItems.items.Length; ind++)
{
if (items[ind] != cs_StartItems.items[ind])
{
resultFlag = false;
}
}
}
// Check starting ability values
if (thStart.Length == cs_StartItems.thStart.Length)
{
for (int ind2 = 0; ind2 < cs_StartItems.thStart.Length; ind2++)
{
if (thStart[ind2] != cs_StartItems.thStart[ind2])
{
resultFlag = false;
}
}
}
Assert.IsTrue(resultFlag);
}
public void test_NextItem_D(int numofItems, ModelNames.CriterionTypes paramCriterion)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + numofItems + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Length, false);
// New Dictionary
itemBank.SetItemParamter(CATItems.ColumnNames.a, DichoItems[0].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.b, DichoItems[1].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.c, DichoItems[2].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.d, DichoItems[3].Select(y => (double)y).ToArray());
// Call "thetaEst" function
//NumericVector r_th = engineObj.Evaluate("r_th <- thetaEst(rbind(DichoItems[3,], DichoItems[13,]), c(0, 1), method = \"WL\")").AsNumeric();
//engineObj.SetSymbol("r_th", r_th);
//double cs_th = CatRLib.ThetaEst(itemBank.FindItem(new int[] { 3, 13 }), x: new int[] { 0, 1 }, model: "", method: ModelNames.EstimaatorMethods.WL.EnumToString());
// Call "NextItem" function from R with parameter "out"
GenericVector r_NextItem = engineObj.Evaluate("r_NextItem <- nextItem(DichoItems, theta = 0, out = c(3, 13), criterion = \"" + paramCriterion.ToString() + "\")").AsList();
// Call "NextItem" function from R with response pattern "x"
//GenericVector r_NextItem = engineObj.Evaluate("r_NextItem <- nextItem(DichoItems, x = c(0, 1), out = c(3, 13), theta = r_th, criterion = \"" + paramCriterion.ToString() + "\")").AsList();
// Selected item
NumericVector item = r_NextItem[0].AsNumeric();
DataFrame par = r_NextItem[1].AsDataFrame();
// Item parameter
CATItems parItems = new CATItems(par[0].Length, false);
parItems.SetItemParamter(CATItems.ColumnNames.a, par[0].Select(y => (double)y).ToArray());
parItems.SetItemParamter(CATItems.ColumnNames.b, par[1].Select(y => (double)y).ToArray());
parItems.SetItemParamter(CATItems.ColumnNames.c, par[2].Select(y => (double)y).ToArray());
parItems.SetItemParamter(CATItems.ColumnNames.d, par[3].Select(y => (double)y).ToArray());
// Value of "info"
NumericVector info = r_NextItem[2].AsNumeric();
// Criterion
CharacterVector startSelect = r_NextItem[3].AsCharacter();
// Call "NextItem" function from CS with parameter "out"
NextItemModel cs_NextItem = CatRLib.NextItem(itemBank, theta: 0, Out: new int[] { 3, 13 }, criterion: (int)paramCriterion);
// Call "NextItem" function from CS with response pattern "x"
//NextItemModel cs_NextItem = CatRLib.NextItem(itemBank, theta: cs_th, Out: new int[] { 3, 13 }, x: new int[] { 0, 1 }, criterion: (int)paramCriterion);
// Checking item & other values
if (item[0] != cs_NextItem.item)
{
resultFlag = false;
}
if (decimal.Round((decimal)info[0], 3) != decimal.Round((decimal)cs_NextItem.info, 3))
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
public void test_StartItems_P(int numofItems, ModelNames.Models paramModel)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + numofItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
// Call "StartItems" function from R, "MFI" criterion
GenericVector r_StartItems = engineObj.Evaluate("r_StartItems <- startItems(PolyItems, model = modelName, nrItems = 3, theta = 1, halfRange = 2)").AsList();
// Resulting item numbers
IntegerVector items = r_StartItems[0].AsInteger();
DataFrame tempitems = r_StartItems[1].AsDataFrame();
// Resulting Items
CATItems r_CatItems = new CATItems(tempitems[0].Length, paramModel.EnumToString(), 5);
for (int i = 0; i < cols.Length; i++)
{
r_CatItems.SetItemParamter(cols[i], tempitems[i].Select(y => (double)y).ToArray());
}
// Resulting
NumericVector thStart = r_StartItems[2].AsNumeric();
CharacterVector startSelect = r_StartItems[3].AsCharacter();
// Call "StartItems" function from CS
StartItemsModel cs_StartItems = CatRLib.StartItems(itemBank, paramModel.EnumToString(), nrItems: 3, theta: 1, halfRange: 2);
// Check items
if (items.Length == cs_StartItems.items.Length)
{
for (int ind = 0; ind < cs_StartItems.items.Length; ind++)
{
if (items[ind] != cs_StartItems.items[ind])
{
resultFlag = false;
}
}
}
// Check starting ability values
if (thStart.Length == cs_StartItems.thStart.Length)
{
for (int ind2 = 0; ind2 < cs_StartItems.thStart.Length; ind2++)
{
if (thStart[ind2] != cs_StartItems.thStart[ind2])
{
resultFlag = false;
}
}
}
Assert.IsTrue(resultFlag);
}
public void test_ThetaEST_SemTheta_D(int numberOfItems)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
//DataFrame tcals = engineObj.Evaluate("tcals <- read.delim(\"D:/PROJECT/DIPF_Project/catR/data/tcals.txt\")").AsDataFrame();
//engineObj.SetSymbol("tcals", tcals);
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
//DataFrame DichoItems = engineObj.Evaluate("DichoItems <- tcals[1:80,1:4]").AsDataFrame();
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + numberOfItems + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
//Creation of a response pattern
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(-1, DichoItems)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
Console.WriteLine("Start of R Processing: " + DateTime.Now.TimeOfDay.ToString());
// Call "thetaEST" function from R
NumericVector r_ThetaEst = engineObj.Evaluate("r_Theta <- thetaEst(DichoItems, x_val, method=\"EAP\")").AsNumeric();
engineObj.SetSymbol("r_ThetaEst", r_ThetaEst);
Console.WriteLine("R Theta Calculation Finished on: " + DateTime.Now.TimeOfDay.ToString());
// TESTING PURPOSE
CATItems itemBank = new CATItems(DichoItems[0].Select(y => (double)y).ToArray(), DichoItems[1].Select(y => (double)y).ToArray(),
DichoItems[2].Select(y => (double)y).ToArray(), DichoItems[3].Select(y => (double)y).ToArray());
int[] x = x_val.Select(y => (int)y).ToArray();
// Call "SemTheta" function from R
//NumericVector r_ThetaSem = engineObj.Evaluate("r_ThetaSem <- semTheta(r_ThetaEst, DichoItems)").AsNumeric();
Console.WriteLine("Start of CS Processing: " + DateTime.Now.TimeOfDay.ToString());
var stopwatch = new Stopwatch();
stopwatch.Restart();
// Call "thetaEST" function from CS
double cs_ThetaEst = CatRLib.ThetaEst(itemBank, x, "", new double[] { 0, 1 }, new double[] { -4, 4 }, new int[] { -4, 4, 33 }, 1, method: "EAP");
Console.WriteLine("Time taken: " + stopwatch.ElapsedMilliseconds);
Console.WriteLine("CS Theta Calculation Finished on: " + DateTime.Now.TimeOfDay.ToString());
// Call "SemTheta" function from CS
//double cs_ThetaSem = CatRLib.SemTheta(cs_ThetaEst, itemBank);
// Compare result of function "ThetaEst"
if (decimal.Round(Convert.ToDecimal(r_ThetaEst[0]), decimalPoint) - decimal.Round(Convert.ToDecimal(cs_ThetaEst), decimalPoint) > decimal.Round(Convert.ToDecimal(testEpsilon), decimalPoint))
{
resultFlag = false;
}
// Compare result of function "SemTheta"
/*if (decimal.Round(Convert.ToDecimal(r_ThetaSem[0]), decimalPoint) - decimal.Round(Convert.ToDecimal(cs_ThetaSem), decimalPoint) > decimal.Round(Convert.ToDecimal(testEpsilon), decimalPoint))
* {
* resultFlag = false;
* }*/
Console.WriteLine("Theta Values: " + decimal.Round(Convert.ToDecimal(r_ThetaEst[0]), decimalPoint) + " , " + decimal.Round(Convert.ToDecimal(cs_ThetaEst), decimalPoint));
Assert.IsTrue(resultFlag);
}
public void testEPV_P(int NumOfItems, ModelNames.Models paramModel)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + NumOfItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
#region "Test block for Ability Values (th)"
double[] th = CatRcs.Utils.CommonHelper.Sequence(-6, 6, length: 11);
for (int j = 0; j < th.Length; j++)
{
string temp = th[j].ToString(nfi);
// Polytomous Items
DataFrame it_given_R = engineObj.Evaluate("it_given_R <- PolyItems[c(4, 8),]").AsDataFrame();
engineObj.SetSymbol("it_given_R", it_given_R);
//Creation of a response pattern for theta value
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(" + th[j].ToString(nfi) + ", it_given_R, model = modelName)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
CATItems it_given = itemBank.FindItem(new int[] { 4, 8 });
// Call "EPV" function from R
NumericVector r_epv = engineObj.Evaluate("r_epv <- EPV(PolyItems, 1, x_val, " + th[j].ToString(nfi) + ", it_given_R, model = modelName)").AsNumeric();
// Call "EPV" function from CatRCS
double cs_epv = CatRLib.EPV(itemBank, 1, x, th[j], it_given, paramModel.EnumToString());
if (r_epv[0] - cs_epv > testEpsilon)
{
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
#endregion
}
public static void Main(string[] args)
{
//f<double[], double> delObj = new f<double[], double>(Method2);
//Console.WriteLine(delObj(new double[] {1, 4, 5}).ToString());
ModelNames.Models paramModel = ModelNames.Models.GRM;
int NumOfItems = 50;
resultFlag = true;
var stopwatch = new Stopwatch();
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + NumOfItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(NumOfItems: NumOfItems, model: paramModel.EnumToString(), nrCat: 5);
for (int i = 0; i < itemBank.colSize; i++)
{
itemBank.all_items_poly[i] = PolyItems[i].Select(y => (double)y).ToArray();
}
//Creation of a response pattern
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(0, PolyItems, model = modelName)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
Console.WriteLine("Start of R Processing: " + DateTime.Now.TimeOfDay.ToString());
stopwatch.Restart();
// Call "ThetaEST" function from R, method = \"ML\"
NumericVector r_ThetaEst = engineObj.Evaluate("r_ThetaEst <- thetaEst(PolyItems, x_val, model = modelName, method = \"BM\", priorDist = \"norm\", priorPar = c(-2, 2))").AsNumeric();
engineObj.SetSymbol("r_ThetaEst", r_ThetaEst);
Console.WriteLine("R Time taken: " + stopwatch.ElapsedMilliseconds);
Console.WriteLine("R Theta Calculation Finished on: " + DateTime.Now.TimeOfDay.ToString());
double[] priorPar = new double[2]; priorPar[0] = -2; priorPar[1] = 2;
Console.WriteLine("Start of CS Processing: " + DateTime.Now.TimeOfDay.ToString());
stopwatch.Restart();
// Call "ThetaEST" function from CS
double cs_ThetaEst = CatRLib.ThetaEst(it: itemBank, x: x, method: "BM", model: paramModel.EnumToString(), priorPar: priorPar, priorDist: "norm");
Console.WriteLine("CS Time taken: " + stopwatch.ElapsedMilliseconds);
Console.WriteLine("CS Theta Calculation Finished on: " + DateTime.Now.TimeOfDay.ToString());
// Compare result of function "ThetaEst"
if (decimal.Round(Convert.ToDecimal(r_ThetaEst[0]), decimalPoint) - decimal.Round(Convert.ToDecimal(cs_ThetaEst), decimalPoint) > decimal.Round(Convert.ToDecimal(testEpsilon), decimalPoint))
{
resultFlag = false;
}
if (resultFlag)
{
Console.WriteLine("Values matched !!");
}
else
{
Console.WriteLine("Values are not matched !!");
}
}
public void testIi_P(ModelNames.Models paramModel)
{
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(10, 5, model = modelName, same.nrCat = FALSE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(NumOfItems: PolyItems[0].Length, model: paramModel.EnumToString(), same_nrCat: false, nrCat: 5);
for (int i = 0; i < itemBank.colSize; i++)
{
itemBank.all_items_poly[i] = PolyItems[i].Select(y => (double)y).ToArray();
}
for (int j = 0; j < itemBank.colSize; j++)
{
for (int k = 0; k < itemBank.NumOfItems; k++)
{
if (CatRcs.Utils.CheckNaValues.IsNaNvalue(itemBank.all_items_poly[j][k]))
{
itemBank.all_items_poly[j][k] = double.NaN;
}
}
}
#region "Test block for Ability Values (th)"
IiList objIi = null;
int decimalPoint = 6;
double[] th_Values = CatRcs.Utils.CommonHelper.Sequence(-4, 4, by: 1);
Console.WriteLine("******* TEST for Ability value Theta ********");
for (int k = 0; k < th_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector th_val = engineObj.CreateNumericVector(new double[] { th_Values[k] });
engineObj.SetSymbol("th_val", th_val);
// Calling the Ii function from R
GenericVector result_Ii = engineObj.Evaluate("result_Ii <- Ii(th = th_val, PolyItems, model = modelName, D = 1)").AsList();
// Getting the function result
NumericVector Ii = result_Ii[0].AsNumeric();
NumericVector dIi = result_Ii[1].AsNumeric();
NumericVector d2Ii = result_Ii[2].AsNumeric();
Console.WriteLine("Value of Theta: " + th_Values[k]);
objIi = CatRLib.Ii(th_Values[k], itemBank, paramModel.EnumToString(), 1);
#region "Ii"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Ii ******");
for (int i = 0; i < objIi.Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.Ii[i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Ii result is Passed!");
#endregion
#region "dIi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dIi ******");
for (int i = 0; i < objIi.dIi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dIi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.dIi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dIi result is Passed!");
#endregion
#region "d2Ii"
z = 0;
resultFlag = true;
Console.WriteLine("****** d2Ii ******");
for (int i = 0; i < objIi.d2Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d2Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.d2Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Ii result is Passed!");
#endregion
}
#endregion
#region "Test block for Metric values"
objIi = null;
double[] D_Values = CatRcs.Utils.CommonHelper.Sequence(0.5, 1, by: 0.1);
Console.WriteLine("******* TEST for Metric Constant ********");
for (int k = 0; k < D_Values.Length; k++)
{
// Sequence Generation for Metric values
NumericVector D_val = engineObj.CreateNumericVector(new double[] { D_Values[k] });
engineObj.SetSymbol("D_val", D_val);
// Calling the Ii function from R
GenericVector result_Ii = engineObj.Evaluate("result_Ii <- Ii(th = 0, PolyItems, model = modelName, D = D_val)").AsList();
// Getting the function result
NumericVector Ii = result_Ii[0].AsNumeric();
NumericVector dIi = result_Ii[1].AsNumeric();
NumericVector d2Ii = result_Ii[2].AsNumeric();
Console.WriteLine("Value of Metric Constant: " + D_Values[k]);
objIi = CatRLib.Ii(0, itemBank, paramModel.EnumToString(), D_Values[k]);
#region "Ii"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Ii ******");
for (int i = 0; i < objIi.Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Ii result is Passed!");
#endregion
#region "dIi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dIi ******");
for (int i = 0; i < objIi.dIi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dIi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.dIi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dIi result is Passed!");
#endregion
#region "d2Ii"
z = 0;
resultFlag = true;
Console.WriteLine("****** d2Ii ******");
for (int i = 0; i < objIi.d2Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d2Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.d2Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Ii result is Passed!");
#endregion
}
#endregion
}
public void testIi_D()
{
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = 10)").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Length, false);
// New Dictionary
itemBank.SetItemParamter(CATItems.ColumnNames.a, DichoItems[0].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.b, DichoItems[1].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.c, DichoItems[2].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.d, DichoItems[3].Select(y => (double)y).ToArray());
#region "Test block for Ability Values (th)"
IiList objIi = null;
int decimalPoint = 6;
double[] th_Values = CatRcs.Utils.CommonHelper.Sequence(-4, 4, by: 1);
Console.WriteLine("******* TEST for Ability value Theta ********");
for (int k = 0; k < th_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector th_val = engineObj.CreateNumericVector(new double[] { th_Values[k] });
engineObj.SetSymbol("th_val", th_val);
// Calling the Ii function from R
GenericVector result_Ii = engineObj.Evaluate("result_Ii <- Ii(th = th_val, DichoItems)").AsList();
// Getting the function result
NumericVector Ii = result_Ii[0].AsNumeric();
NumericVector dIi = result_Ii[1].AsNumeric();
NumericVector d2Ii = result_Ii[2].AsNumeric();
Console.WriteLine("Value of Theta: " + th_Values[k]);
objIi = CatRLib.Ii(th_Values[k], itemBank, "", 1);
#region "Ii"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Ii ******");
for (int i = 0; i < objIi.Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Ii result is Passed!");
#endregion
#region "dIi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dIi ******");
for (int i = 0; i < objIi.dIi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dIi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.dIi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dIi result is Passed!");
#endregion
#region "d2Ii"
z = 0;
resultFlag = true;
Console.WriteLine("****** d2Ii ******");
for (int i = 0; i < objIi.d2Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d2Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.d2Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Ii result is Passed!");
#endregion
}
#endregion
#region "Test block for Metric values"
objIi = null;
double[] D_Values = CatRcs.Utils.CommonHelper.Sequence(0.5, 1, by: 0.1);
Console.WriteLine("******* TEST for Metric Constant ********");
for (int k = 0; k < D_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector D_val = engineObj.CreateNumericVector(new double[] { D_Values[k] });
engineObj.SetSymbol("D_val", D_val);
// Calling the Ii function from R
GenericVector result_Ii = engineObj.Evaluate("result_Ii <- Ii(th = 0, DichoItems, D = D_val)").AsList();
// Getting the function result
NumericVector Ii = result_Ii[0].AsNumeric();
NumericVector dIi = result_Ii[1].AsNumeric();
NumericVector d2Ii = result_Ii[2].AsNumeric();
Console.WriteLine("Value of Metric Constant: " + D_Values[k]);
objIi = CatRLib.Ii(0, itemBank, "", D_Values[k]);
#region "Ii"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Ii ******");
for (int i = 0; i < objIi.Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Ii result is Passed!");
#endregion
#region "dIi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dIi ******");
for (int i = 0; i < objIi.dIi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dIi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.dIi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dIi result is Passed!");
#endregion
#region "d2Ii"
z = 0;
resultFlag = true;
Console.WriteLine("****** d2Ii ******");
for (int i = 0; i < objIi.d2Ii.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d2Ii[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objIi.d2Ii[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Ii result is Passed!");
#endregion
}
#endregion
}
public void testJi_P(ModelNames.Models paramModel)
{
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(100, 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
#region "Test block for Ability Values (th)"
JiList objJi = null;
int decimalPoint = 6;
double[] th_Values = CatRcs.Utils.CommonHelper.Sequence(-6, 6, by: 1);
Console.WriteLine("******* TEST for Ability value Theta ********");
for (int k = 0; k < th_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector th_val = engineObj.CreateNumericVector(new double[] { th_Values[k] });
engineObj.SetSymbol("th_val", th_val);
// Calling the "Ji" function from R
GenericVector result_Ji = engineObj.Evaluate("result_Ji <- Ji(th = th_val, PolyItems, model = modelName, D = 1)").AsList();
// Getting the function result
NumericVector Ji = result_Ji[0].AsNumeric();
NumericVector dJi = result_Ji[1].AsNumeric();
Console.WriteLine("Value of Theta: " + th_Values[k]);
objJi = CatRLib.Ji(th_Values[k], itemBank, paramModel.EnumToString(), 1);
#region "Ji"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Ji ******");
for (int i = 0; i < objJi.Ji.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Ji[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objJi.Ji[i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
Console.WriteLine("Value from R: " + decimal.Round(Convert.ToDecimal(Ji[i]), decimalPoint));
Console.WriteLine("Value from CS: " + decimal.Round(Convert.ToDecimal(objJi.Ji[i]), decimalPoint));
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Ji result is Passed!");
#endregion
#region "dJi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dJi ******");
for (int i = 0; i < objJi.dJi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dJi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objJi.dJi[i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dJi result is Passed!");
#endregion
}
#endregion
#region "Test block for Metric values"
objJi = null;
double[] D_Values = CatRcs.Utils.CommonHelper.Sequence(0.5, 1, by: 0.1);
Console.WriteLine("******* TEST for Metric Constant ********");
for (int k = 0; k < D_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector D_val = engineObj.CreateNumericVector(new double[] { D_Values[k] });
engineObj.SetSymbol("D_val", D_val);
// Calling the "Ji" function from R
GenericVector result_Ji = engineObj.Evaluate("result_Ji <- Ji(th = 0, PolyItems, model = modelName, D = D_val)").AsList();
// Getting the function result
NumericVector Ji = result_Ji[0].AsNumeric();
NumericVector dJi = result_Ji[1].AsNumeric();
Console.WriteLine("Value of Metric Constant: " + D_Values[k]);
objJi = CatRLib.Ji(0, itemBank, paramModel.EnumToString(), D_Values[k]);
#region "Ji"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Ji ******");
for (int i = 0; i < objJi.Ji.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Ji[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objJi.Ji[i]), decimalPoint))
{
/*Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
* Console.WriteLine("Value from R: " + decimal.Round(Convert.ToDecimal(Ji[i]), decimalPoint));
* Console.WriteLine("Value from CS: " + decimal.Round(Convert.ToDecimal(objJi.Ji[i]), decimalPoint));*/
resultFlag = false;
}
}
//Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Ji result is Passed!");
#endregion
#region "dJi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dJi ******");
for (int i = 0; i < objJi.dJi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dJi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objJi.dJi[i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dJi result is Passed!");
#endregion
}
#endregion
}
public void test_MEI_D(int NumOfItems)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + NumOfItems + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Length, false);
// New Dictionary
itemBank.SetItemParamter(CATItems.ColumnNames.a, DichoItems[0].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.b, DichoItems[1].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.c, DichoItems[2].Select(y => (double)y).ToArray());
itemBank.SetItemParamter(CATItems.ColumnNames.d, DichoItems[3].Select(y => (double)y).ToArray());
// test for different theta values
double[] th = CatRcs.Utils.CommonHelper.Sequence(-6, 6, length: 11);
for (int t = 0; t < th.Length - 1; t++)
{
string temp = th[t].ToString(nfi);
// Dichotomous Items
DataFrame it_given_R = engineObj.Evaluate("it_given_R <- DichoItems[c(4, 8),]").AsDataFrame();
engineObj.SetSymbol("it_given_R", it_given_R);
//Creation of a response pattern for theta value
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(" + th[t].ToString(nfi) + ", it_given_R)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
CATItems it_given = itemBank.FindItem(new int[] { 4, 8 });
// Call "MEI" function from R
NumericVector r_mei = engineObj.Evaluate("r_mei <- MEI(DichoItems, 1, x_val, " + th[t].ToString(nfi) + ", it_given_R)").AsNumeric();
// Call "MEI" function from CatRCS
double cs_mei = CatRLib.MEI(itemBank, 1, x, th[t], it_given, "");
if (t != 6) // Not matched for value of theta = 1.2, R = 0.1524265206388655, CS = 0.15242411819250282
{
if (decimal.Round(Convert.ToDecimal(r_mei[0]), decimalPoint) - decimal.Round(Convert.ToDecimal(cs_mei), decimalPoint) > Convert.ToDecimal(testEpsilon))
{
resultFlag = false;
}
}
}
Assert.IsTrue(resultFlag);
}
public void testEapEST_and_EapSEM_P(int NumOfItems, ModelNames.Models paramModel)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + NumOfItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
#region "Test block for Ability Values (th)"
double[] th = CatRcs.Utils.CommonHelper.Sequence(-6, 6, length: 11);
for (int j = 0; j < th.Length; j++)
{
string temp = th[j].ToString(nfi);
//Creation of a response pattern for theta value
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(" + "th = " + th[j].ToString(nfi) + ", PolyItems, " + "model = modelName)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
// Call "EapEST" function from R
NumericVector r_eapEst = engineObj.Evaluate("result_Eap <- eapEst(PolyItems, x_val, model = modelName)").AsNumeric();
// Call "EapEST" function from CatRCS
double cs_eapEst = CatRLib.EapEST(itemBank, x, paramModel.EnumToString());
/* EapEst function, line 111 needs to be optimized for passing the Test
* Check EapSEM function too !! */
// Call "EapSEM" function from R
NumericVector r_eapSem = engineObj.Evaluate("result_EapSem <- eapSem(result_Eap, PolyItems, x_val, model = modelName)").AsNumeric();
// Call "EapSEM" function from CatRCS
double cs_eapSem = CatRLib.EapSEM(cs_eapEst, itemBank, x, paramModel.EnumToString());
if (r_eapEst[0] - cs_eapEst > testEpsilon ||
r_eapSem[0] - cs_eapSem > testEpsilon)
{
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
#endregion
}
public void testEPV_D()
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = 200)").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Select(y => (double)y).ToArray(), DichoItems[1].Select(y => (double)y).ToArray(),
DichoItems[2].Select(y => (double)y).ToArray(), DichoItems[3].Select(y => (double)y).ToArray());
// test for different theta values
double[] th = CatRcs.Utils.CommonHelper.Sequence(-6, 6, length: 11);
var stopwatch = new Stopwatch();
stopwatch.Restart();
for (int t = 0; t < th.Length; t++)
{
string temp = th[t].ToString(nfi);
// Dichotomous Items
DataFrame it_given_R = engineObj.Evaluate("it_given_R <- DichoItems[c(4, 8),]").AsDataFrame();
engineObj.SetSymbol("it_given_R", it_given_R);
//Creation of a response pattern for theta value
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(" + th[t].ToString(nfi) + ", it_given_R)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
int[] index = new int[] { 4, 8 };
CATItems it_given = new CATItems(index.Length); // itemBank.FindItem(new int[] { 4, 8 });
for (int i = 0; i < index.Length; i++)
{
it_given.a[i] = itemBank.a[index[i] - 1];
it_given.b[i] = itemBank.b[index[i] - 1];
it_given.c[i] = itemBank.c[index[i] - 1];
it_given.d[i] = itemBank.d[index[i] - 1];
}
// Call "EPV" function from R
NumericVector r_epv = engineObj.Evaluate("r_epv <- EPV(DichoItems, 1, x_val, " + th[t].ToString(nfi) + ", it_given_R)").AsNumeric();
stopwatch.Restart();
// Call "EPV" function from CatRCS
double cs_epv = CatRLib.EPV(itemBank, 1, x, th[t], it_given, "");
Console.WriteLine("Time taken: " + stopwatch.ElapsedMilliseconds);
if (r_epv[0] - cs_epv > testEpsilon)
{
resultFlag = false;
}
Console.WriteLine(r_epv[0] + " " + cs_epv);
}
Assert.IsTrue(resultFlag);
}
public void testPi_D()
{
bool OSProc = System.Environment.Is64BitProcess;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = 100)").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Select(y => (double)y).ToArray(), DichoItems[1].Select(y => (double)y).ToArray(),
DichoItems[2].Select(y => (double)y).ToArray(), DichoItems[3].Select(y => (double)y).ToArray());
#region "Test block for Ability Values (th)"
PiList objPI = null;
int decimalPoint = 4;
double[] th_Values = CatRcs.Utils.CommonHelper.Sequence(-6, 6, by: 1);
Console.WriteLine("******* TEST for Ability value Theta ********");
for (int k = 0; k < th_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector th_val = engineObj.CreateNumericVector(new double[] { th_Values[k] });
engineObj.SetSymbol("th_val", th_val);
// Calling the "Pi" from R
GenericVector result_Pi = engineObj.Evaluate("result_Pi <- Pi(th = th_val, DichoItems, D = 1)").AsList();
// Getting the function result
NumericVector Pi = result_Pi[0].AsNumeric();
NumericVector dPi = result_Pi[1].AsNumeric();
NumericVector d2Pi = result_Pi[2].AsNumeric();
NumericVector d3Pi = result_Pi[3].AsNumeric();
Console.WriteLine("Value of Theta: " + th_Values[k]);
objPI = CatRLib.Pi_D(th_Values[k], itemBank, "", 1);
#region "Pi"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Pi ******");
for (int i = 0; i < Pi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Pi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.Pi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag, "Passed");
Console.WriteLine("Values of Pi are Matched!");
#endregion
#region "dPi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dPi ******");
for (int i = 0; i < dPi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dPi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.dPi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dPi are Matched!");
#endregion
#region "d2Pi"
z = 0;
resultFlag = true;
Console.WriteLine("****** d2Pi ******");
for (int i = 0; i < d2Pi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d2Pi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.d2Pi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Pi are Matched!");
#endregion
#region "d3Pi"
z = 0;
resultFlag = true;
Console.WriteLine("****** d3Pi ******");
for (int i = 0; i < d3Pi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d3Pi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.d3Pi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d3Pi are Matched!");
#endregion
}
Assert.IsTrue(resultFlag);
#endregion
#region "Test block for Metric values"
objPI = null;
double[] D_Values = CatRcs.Utils.CommonHelper.Sequence(0.5, 1, by: 0.1);
Console.WriteLine("******* TEST for Metric Constant ********");
for (int k = 0; k < D_Values.Length; k++)
{
// Sequence Generation for Theta (Ability) values
NumericVector D_val = engineObj.CreateNumericVector(new double[] { D_Values[k] });
engineObj.SetSymbol("D_val", D_val);
// Calling the "Pi" from R
GenericVector result_Pi = engineObj.Evaluate("result_Pi <- Pi(th = 0, DichoItems, D = D_val)").AsList();
// Getting the function result
NumericVector Pi = result_Pi[0].AsNumeric();
NumericVector dPi = result_Pi[1].AsNumeric();
NumericVector d2Pi = result_Pi[2].AsNumeric();
NumericVector d3Pi = result_Pi[3].AsNumeric();
Console.WriteLine("Value of Metric constant: " + D_Values[k]);
objPI = CatRLib.Pi_D(0, itemBank, "", D_Values[k]);
#region "Pi"
int z = 0;
resultFlag = true;
Console.WriteLine("****** Pi ******");
for (int i = 0; i < Pi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(Pi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.Pi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Pi are matched!");
#endregion
#region "dPi"
z = 0;
resultFlag = true;
Console.WriteLine("****** dPi ******");
for (int i = 0; i < dPi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(dPi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.dPi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dPi are matched!");
#endregion
#region "d2Pi"
z = 0;
resultFlag = true;
Console.WriteLine("****** d2Pi ******");
for (int i = 0; i < d2Pi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d2Pi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.d2Pi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Pi are Matched!");
#endregion
#region "d3Pi"
z = 0;
resultFlag = true;
Console.WriteLine("****** d3Pi ******");
for (int i = 0; i < d3Pi.Length; i++)
{
z = i + 1; // item number
if (decimal.Round(Convert.ToDecimal(d3Pi[i]), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.d3Pi[i]), decimalPoint))
{
//Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d3Pi are Matched!");
#endregion
}
#endregion
}
public void testEapEST_and_EapSEM_D()
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Test for item banks with different number of items
for (int i1 = 0; i1 < numberOfItems.Length; i1++)
{
// Dichotomous Items
DataFrame DichoItems = engineObj.Evaluate("DichoItems <- genDichoMatrix(items = " + numberOfItems[i1] + ")").AsDataFrame();
engineObj.SetSymbol("DichoItems", DichoItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
CATItems itemBank = new CATItems(DichoItems[0].Select(y => (double)y).ToArray(), DichoItems[1].Select(y => (double)y).ToArray(),
DichoItems[2].Select(y => (double)y).ToArray(), DichoItems[3].Select(y => (double)y).ToArray());
// test for different theta values
double[] th = CatRcs.Utils.CommonHelper.Sequence(-6, 6, length: 11);
var stopwatch = new Stopwatch();
stopwatch.Restart();
for (int i2 = 0; i2 < th.Length; i2++)
{
string temp = th[i2].ToString(nfi);
//Creation of a response pattern for theta value
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(" + th[i2].ToString(nfi) + ", DichoItems)").AsNumeric();
int[] x = x_val.Select(y => (int)y).ToArray();
// Call "EapEST" function from R
NumericVector r_eapEst = engineObj.Evaluate("result_Eap <- eapEst(DichoItems, x_val)").AsNumeric();
// Call "EapSEM" function from R
NumericVector r_eapSem = engineObj.Evaluate("result_EapSem <- eapSem(result_Eap, DichoItems, x_val)").AsNumeric();
stopwatch.Restart();
// Call "EapEST" function from CatRCS
double cs_eapEst = CatRLib.EapEST(itemBank, x, "");
// Call "EapSEM" function from CatRCS
double cs_eapSem = CatRLib.EapSEM(cs_eapEst, itemBank, x, "");
Console.WriteLine("Time: " + stopwatch.ElapsedMilliseconds);
if (r_eapEst[0] - cs_eapEst > testEpsilon ||
r_eapSem[0] - cs_eapSem > testEpsilon)
{
resultFlag = false;
}
}
}
Assert.IsTrue(resultFlag, "Test Passed!");
}
public void testPi_P_New(ModelNames.Models paramModel)
{
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(100, 5, model = modelName, same.nrCat = FALSE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(NumOfItems: PolyItems[0].Length, model: paramModel.EnumToString(), nrCat: 5);
for (int i = 0; i < itemBank.colSize; i++)
{
itemBank.all_items_poly[i] = PolyItems[i].Select(y => (double)y).ToArray();
}
PiListPoly objPI = null;
int decimalPoint = 4;
double[] th_Values = CatRcs.Utils.CommonHelper.Sequence(-4, 4, by: 1);
NumericVector th_val = engineObj.CreateNumericVector(new double[] { th_Values[0] });
engineObj.SetSymbol("th_val", th_val);
// Calling the "Pi" from R
GenericVector result_Pi = engineObj.Evaluate("result_Pi <- Pi(th = th_val, PolyItems, model = modelName, D = 1)").AsList();
// Getting the "Pi" function result
NumericVector Pi = result_Pi[0].AsNumeric();
NumericVector dPi = result_Pi[1].AsNumeric();
NumericVector d2Pi = result_Pi[2].AsNumeric();
NumericVector d3Pi = result_Pi[3].AsNumeric();
Console.WriteLine("Value of Theta: " + th_Values[0]);
// Calling "Pi" function
objPI = CatRLib.Pi_P(th_Values[0], itemBank, paramModel.EnumToString(), 1);
#region "Pi"
int z = 0, pi_index = 0;
resultFlag = true;
Console.WriteLine("****** Pi ******");
int len = objPI.Pi.GetLength(0);
int len2 = objPI.Pi.GetLength(1);
for (int i = 0; i < objPI.Pi.GetLength(1); i++) // column
{
z = i + 1; // item number
for (int j = 0; j < objPI.Pi.GetLength(0); j++) // row
{
double tempPiVal = !CatRcs.Utils.CheckNaValues.IsNaNvalue(Pi[pi_index]) ? Pi[pi_index] : 0;
if (decimal.Round(Convert.ToDecimal(tempPiVal), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.Pi[j, i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
pi_index++;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of Pi are Matched!");
#endregion
#region "dPi"
z = 0; pi_index = 0;
resultFlag = true;
Console.WriteLine("****** dPi ******");
for (int i = 0; i < objPI.dPi.GetLength(1); i++) // column
{
z = i + 1; // item number
for (int j = 0; j < objPI.dPi.GetLength(0); j++) // row
{
double tempPiVal = !CatRcs.Utils.CheckNaValues.IsNaNvalue(dPi[pi_index]) ? dPi[pi_index] : 0;
if (decimal.Round(Convert.ToDecimal(tempPiVal), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.dPi[j, i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
pi_index++;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of dPi are Matched!");
#endregion
#region "d2Pi"
z = 0; pi_index = 0;
resultFlag = true;
Console.WriteLine("****** d2Pi ******");
for (int i = 0; i < objPI.d2Pi.GetLength(1); i++) // column
{
z = i + 1; // item number
for (int j = 0; j < objPI.d2Pi.GetLength(0); j++) // row
{
double tempPiVal = !CatRcs.Utils.CheckNaValues.IsNaNvalue(d2Pi[pi_index]) ? d2Pi[pi_index] : 0;
if (decimal.Round(Convert.ToDecimal(tempPiVal), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.d2Pi[j, i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
pi_index++;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d2Pi are Matched!");
#endregion
#region "d3Pi"
z = 0; pi_index = 0;
resultFlag = true;
Console.WriteLine("****** d3Pi ******");
for (int i = 0; i < objPI.d3Pi.GetLength(1); i++) // column
{
z = i + 1; // item number
for (int j = 0; j < objPI.d3Pi.GetLength(0); j++) // row
{
double tempPiVal = !CatRcs.Utils.CheckNaValues.IsNaNvalue(d3Pi[pi_index]) ? d3Pi[pi_index] : 0;
if (decimal.Round(Convert.ToDecimal(tempPiVal), decimalPoint) != decimal.Round(Convert.ToDecimal(objPI.d3Pi[j, i]), decimalPoint))
{
Console.WriteLine("Test for Item No. # " + z + " is not Passed!");
resultFlag = false;
}
pi_index++;
}
}
Assert.IsTrue(resultFlag);
Console.WriteLine("Values of d3Pi are Matched!");
#endregion
}
public void testKL_P(int NumOfItems, ModelNames.Models paramModel)
{
resultFlag = true;
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + NumOfItems + ", 5, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
CATItems itemBank = new CATItems(PolyItems[0].Length, paramModel.EnumToString(), 5);
Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys();
for (int i = 0; i < cols.Length; i++)
{
itemBank.SetItemParamter(cols[i], PolyItems[i].Select(y => (double)y).ToArray());
}
DataFrame it_given_R = engineObj.Evaluate("it_given_R <- PolyItems[c(4, 8),]").AsDataFrame();
engineObj.SetSymbol("it_given_R", it_given_R);
CATItems it_given = itemBank.FindItem(new int[] { 4, 8 });
//Creation of a response pattern for theta value
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(0, it_given_R, model = modelName)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
// Call "thetaEST" function from R, method = \"ML\"
NumericVector Theta = engineObj.Evaluate("Theta <- thetaEst(it_given_R, x_val, method = \"ML\", model = modelName)").AsNumeric();
// Call "KL" function from R
NumericVector r_KL = engineObj.Evaluate("r_KL <- KL(PolyItems, 1, x_val, it_given_R, theta = Theta, model = modelName)").AsNumeric();
// Call "thetaEST" function from CS
double th_est = CatRLib.ThetaEst(it_given, x, paramModel.EnumToString(), method: "ML");
// Call "KL" function from CS
double cs_KL = CatRLib.KL(itemBank, 1, x, it_given, paramModel.EnumToString(), theta: th_est);
if (r_KL[0] - cs_KL > testEpsilon)
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
public void test_ThetaEST_SemTheta_P(int NumOfItems, ModelNames.Models paramModel)
{
resultFlag = true;
var stopwatch = new Stopwatch();
REngine.SetEnvironmentVariables();
REngine engineObj = REngine.GetInstance();
// Loading a library from R
engineObj.Evaluate("library(catR)");
// Polytomous Items
CharacterVector modelName = engineObj.CreateCharacterVector(new string[] { paramModel.EnumToString() });
engineObj.SetSymbol("modelName", modelName);
DataFrame PolyItems = engineObj.Evaluate("PolyItems <- genPolyMatrix(" + NumOfItems + ", 4, model = modelName, same.nrCat = TRUE)").AsDataFrame();
engineObj.SetSymbol("PolyItems", PolyItems);
// Adapting with the existing "CAT-Items" type (Wrapper)
Console.WriteLine("*******************************************");
Console.WriteLine("Polytomous Items, Model : " + paramModel.EnumToString());
Console.WriteLine("*******************************************");
// Create item object
CATItems itemBank = new CATItems(NumOfItems: NumOfItems, model: paramModel.EnumToString(), nrCat: 4, same_nrCat: false);
//DataFrame iii = engineObj.Evaluate("item_new <- as.matrix(PolyItems)").AsDataFrame();
for (int k = 0; k < itemBank.colSize; k++)
{
itemBank.DataWrapper(PolyItems[k].Select(y => (double)y).ToArray(), k);
}
//itemBank = RtoCSDataHandler.DataConverterRtoCS(itemBank, iii.Select(y => (double)y).ToArray());
//itemBank = RtoCSDataHandler.DataConverterRtoCS(itemBank, PolyItems);
//Creation of a response pattern
engineObj.Evaluate("set.seed(1)");
NumericVector x_val = engineObj.Evaluate("x_val <- genPattern(1, PolyItems, model = modelName)").AsNumeric();
engineObj.SetSymbol("x_val", x_val);
int[] x = x_val.Select(y => (int)y).ToArray();
Console.WriteLine("Start of R Processing: " + DateTime.Now.TimeOfDay.ToString());
stopwatch.Restart();
// Call "ThetaEST" function from R, method = \"ML\"
//NumericVector r_ThetaEst = engineObj.Evaluate("r_ThetaEst <- thetaEst(PolyItems, x_val, model = modelName, method = \"BM\", priorDist = \"norm\", priorPar = c(-2, 2))").AsNumeric();
NumericVector r_ThetaEst = engineObj.Evaluate("r_ThetaEst <- thetaEst(PolyItems, x_val, modelName)").AsNumeric();
engineObj.SetSymbol("r_ThetaEst", r_ThetaEst);
Console.WriteLine("R Time taken: " + stopwatch.ElapsedMilliseconds + " ms");
Console.WriteLine("R Theta Calculation Finished on: " + DateTime.Now.TimeOfDay.ToString());
double[] priorPar = new double[2]; priorPar[0] = -2; priorPar[1] = 2;
Console.WriteLine("Start of CS Processing: " + DateTime.Now.TimeOfDay.ToString());
stopwatch.Restart();
double cs_ThetaEst = CatRLib.ThetaEst(itemBank, x, paramModel.EnumToString());
// Call "ThetaEST" function from CS
//double cs_ThetaEst = CatRLib.ThetaEst(it: itemBank, x: x, method:"BM", model: paramModel.EnumToString(), priorPar: priorPar, priorDist: "norm");
Console.WriteLine("CS Time taken: " + stopwatch.ElapsedMilliseconds + " ms");
Console.WriteLine("CS Theta Calculation Finished on: " + DateTime.Now.TimeOfDay.ToString());
// Compare result of function "ThetaEst"
if (decimal.Round(Convert.ToDecimal(r_ThetaEst[0]), decimalPoint) - decimal.Round(Convert.ToDecimal(cs_ThetaEst), decimalPoint) > decimal.Round(Convert.ToDecimal(testEpsilon), decimalPoint))
{
resultFlag = false;
}
// Call "SemTheta" function from R
NumericVector r_ThetaSem = engineObj.Evaluate("r_ThetaSem <- semTheta(r_ThetaEst, PolyItems, model = modelName, method = \"BM\", priorDist = \"norm\", priorPar = c(-2, 2))").AsNumeric();
// Call "SemTheta" function from CS
double cs_ThetaSem = CatRLib.SemTheta(thEst: cs_ThetaEst, it: itemBank, method: "BM", model: paramModel.EnumToString(), priorPar: priorPar, priorDist: "norm");
// Compare result of function "SemTheta"
if (decimal.Round(Convert.ToDecimal(r_ThetaSem[0]), decimalPoint) - decimal.Round(Convert.ToDecimal(cs_ThetaSem), decimalPoint) > decimal.Round(Convert.ToDecimal(testEpsilon), decimalPoint))
{
resultFlag = false;
}
Assert.IsTrue(resultFlag);
}
