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); }
private void ProcessTheta(int[] items, int[] responses) { CATItems itemBank = null; if ((bool)Session["IsDicho"]) { itemBank = new CATItems(items.Length); Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys(); for (int i = 0; i < cols.Length; i++) { string tempKey = cols[i].Item1.ToString() + cols[i].Item2.ToString(); itemBank.SetItemParamter(cols[i], cat_items[tempKey].Select(y => (double)y).ToArray()); } // Calculate theta CalculateTheta(itemBank, responses); } if ((bool)Session["IsPoly"]) { ModelNames.Models paramModel = ModelNames.Models.GRM; itemBank = new CATItems(items.Length, paramModel.EnumToString(), nrCat: 5); Tuple <CATItems.ColumnNames, int>[] cols = itemBank.GetKeys(); for (int i = 0; i < cols.Length; i++) { string tempKey = cols[i].Item1.ToString() + cols[i].Item2.ToString(); itemBank.SetItemParamter(cols[i], cat_items[tempKey].Select(y => (double)y).ToArray()); } // Calculate theta CalculateTheta(itemBank, responses, model: paramModel.EnumToString()); } }
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_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 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 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 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 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); }