cat_engine 0.1.0

data/lib/cat_engine/version.rb

@@ -0,0 +1,3 @@
+module CatEngine
+  VERSION = "0.1.0"
+end

data/lib/tasks/cat_engine_tasks.rake

@@ -0,0 +1,9 @@
+require "cat_engine/engine"
+
+namespace :cat_engine do
+  desc "compile the CAT Engine"
+  task :compile_cat_engine do
+    CatEngine::Engine.compile
+  end
+end
+

data/vendor/cat_engine/CATEngine3.cs

@@ -0,0 +1,2123 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Collections;
+using System.IO;
+using System.Linq;
+using System.Xml;
+
+
+namespace CORE.Engines
+{
+
+    /// <summary>
+    /// Engine for computer adaptive testing.
+    /// </summary>
+    [Serializable]
+    public class CATEngine3 : IEngine
+    {
+
+        /// <summary>
+        /// Enumerator for the item response theory model type.
+        /// </summary>
+        private enum IRTModelType
+        {
+            /// <summary>GRM: 0</summary>
+            GradedResponseModel,
+            /// <summary>GPCM: 1</summary>
+            GeneralizedPartialCreditModel,
+            /// <summary>WR1PL: 2</summary>
+            WideRange1PL,
+            /// <summary>WR2PL: 3</summary>
+            WideRange2PL
+        };
+
+        /// <summary>
+        /// Enumerator for the Selection Method type. These are types of methods for calculating
+        /// the next item to select.
+        /// </summary>
+        private enum SelectionMethodType
+        {
+            /// <summary>MLWI: 0</summary>
+            MaximumLikelihoodWeightedInformation,
+            /// <summary>MPWI: 1</summary>
+            MaximumPosteriorWeightedInformation,
+            /// <summary>MI: 2</summary>
+            MaximumInformation,
+            /// <summary>ST: 3</summary>
+            Stradaptive,
+            /// <summary>MIN: 4</summary>
+            MaximumInformationWithNoise,
+            /// <summary>STMI: 5</summary>
+            StradaptiveWithMaximumInformation,
+            /// <summary>PR: 6</summary>
+            MaximumInformationProgressiveRestricted
+        };
+
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public CATEngine3()
+        {
+            Init();
+        }
+
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="NumCategoriesByItem">The number of categories by item.</param>
+        /// <param name="DiscriminationValues">The discrimination values.</param>
+        /// <param name="CategoryBoundaryValues">The category boundary values.</param>
+        public CATEngine3(int[] NumCategoriesByItem, double[] DiscriminationValues, double[][] CategoryBoundaryValues)
+        {
+            _NumCategoriesByItem = NumCategoriesByItem;
+            _DiscriminationValues = DiscriminationValues;
+            _CategoryBoundaryValues = CategoryBoundaryValues;
+
+            Init();
+        }
+
+        /// <summary>
+        /// Initializations.
+        /// </summary>
+        private void Init()
+        {
+            _MaxCategories = 0;
+            _MinTheta = 0;
+            _MaxTheta = 0;
+            _ThetaIncrement = 0;
+
+            _Theta = 0;
+            _StdError = 9.900;
+            _NumQuadraturePoints = 0;
+            _Recalculate = true;
+            _CriteriaMet = false;
+            _finished = false;
+            _IsCompleted = false;
+            _IsResume = false;
+
+            _ItemsAsked = new ArrayList();
+            _ItemsSkipped = new ArrayList();
+            _Responses = new ArrayList();
+            _ThetaHistory = new ArrayList();
+            _StdErrorHistory = new ArrayList();
+            _LikelihoodHistory = new ArrayList();
+
+            _Initialized = false;
+            _RandomNumber = new Random(unchecked((int)DateTime.Now.Ticks));
+
+            _position = 0;
+            _store = new ArrayList();
+            _ItemIDs = new Hashtable();
+            _ResponseIDs = new Hashtable();
+
+            _paramPROC = "dbo.loadWideRangeCATParameters";
+            _message = "";
+
+        }
+
+
+        #region Inheirited methods
+
+
+        /// <summary>
+        /// Gets all the form items.
+        /// </summary>
+        /// <returns>XML document with all the form items.</returns>
+        public XmlDocument getForm()
+        {
+            XmlDocument doc = new XmlDocument();
+                doc.LoadXml(_form);
+
+                XmlDocumentFragment docFrag = doc.CreateDocumentFragment();
+                for (int i = 0; i < _store.Count; i++) {
+                    docFrag.InnerXml = (String)_store[i];
+                    XmlNode deep = docFrag.CloneNode(true);
+                    doc.GetElementsByTagName("Items")[0].AppendChild(doc.ImportNode(deep, true));
+                }
+            return doc;
+        }
+
+
+        /// <summary>
+        /// Loads the items into the document store from an XML document.
+        /// </summary>
+        /// <param name="doc">The XML document.</param>
+        /// <param name="FormParams">The form parameters.</param>
+        /// <param name="WithHeader">If set to <c>true</c> treat transition or header items as actual items.</param>
+        /// <returns><c>true</c> if items successfully loaded, otherwise <c>false</c>.</returns>
+        /// <remarks>The form parameters are the CAT parameters in this case. The XML document requires  
+        /// Property nodes within the Calibration node with the following Name and Value attributes with 
+        /// appropriate data types:
+        /// <br/><br/>
+        /// <code>IRTModel</code> Item response theory model to use: integer data type
+        /// <code>SelectionMethod</code> Item selection method: integer data type
+        /// <code>MinNumItems</code> Minimum number of items to administer: integer data type
+        /// <code>MaxNumItems</code> Maximum number of items to administer: integer data type
+        /// <code>MaxStdErr</code> Maximum standard error: double data type
+        /// <code>SelectionGroupSize</code> Group size from which the next item is selected randomly: integer data type
+        /// <code>LogisticScaling</code> Logistic scaling constant: double data type
+        /// <code>DistMean</code> Prior distribution mean: double data type
+        /// <code>DistStdDev</code> Prior distribution standard deviation: double data type
+        /// <code>MinNumStradaptive</code> Minimum number of iterations for Stradaptive method: integer data type
+        /// <code>NoiseRange</code> Noise range around a point: double data type
+        /// <code>DefaultBin</code> Default bin if none are pre-selected: integer data type
+        /// <code>MaxStepChange</code> Maximum step change for maximum likelihood theta estimates: integer data type
+        /// <code>MaxNumIterations</code> Maximum number of iterations for maximum likelihood theta estimates: integer data type
+        /// <code>Convergence</code> Convergence criterion for Wide Range CAT: double data type
+        /// <code>MinTheta</code> Minimum theta value: double data type
+        /// <code>MaxTheta</code> Maximum theta value: double data type
+        /// <code>ThetaIncrement</code> Increment of theta to use for numerical integration: double data type
+        /// <code>FirstItem</code> Specific item to use first: string data type (stores a GUID)
+        /// <br/><br/>
+        /// The XML document will also have per-item properties:<br/><br/>
+        /// <code>A_GRM</code>Discrimination value for the Graded Response Model: double data type
+        /// <code>A_PCM</code>Discrimination value for the Partial Credit Model: double data type
+        /// <code>Slope</code>Discrimination value for the Wide Range 1PL or 2PL model: double data type
+        /// <code>Difficulty</code>Item difficulty for the Wide Range 1PL or 2PL model: double data type
+        /// <code>Bin</code>Item bin assignment for the Wide Range 1PL or 2PL model: integer data type
+        /// <br/><br/>
+        /// The Wide Range CAT methods also require an <code>InitialBin</code> integer value that is determined
+        /// on a per-person basis. This is in the Form XML document rather than the Parameter XML document.
+        /// <br/><br/>
+        /// Required parameters that are missing will throw an ApplicationException, missing optional parameters will not.
+        /// Some parameters are only required if other parameters have certain values and will only throw an ApplicationException
+        /// if those conditions are met.
+        ///</remarks>
+        public bool loadItems(XmlDocument doc, XmlDocument FormParams, bool WithHeader)
+        {
+            bool AreItemsLoaded = false;
+                StringWriter sw;
+                XmlTextWriter xw;
+                string FormItemOID;
+                string ItemResponseOID;
+                XmlNodeList items;
+                XmlNodeList responses;
+                XmlNodeList CATitems;
+                XmlNode CATitem;
+                ArrayList arItemsAvailable = new ArrayList();
+                ArrayList arNumCatByItem = new ArrayList();
+                ArrayList arDisc = new ArrayList();
+                List<double> liDiff = new List<double>();
+                List<int> liBin = new List<int>();
+                ArrayList arCBV = new ArrayList();
+                ArrayList arItemCBV;
+                Hashtable ItemResponseIDs;
+                ArrayList arNumCat = new ArrayList();
+                int j;
+                int counter = -1;  // Count of items that have parameters
+                int lowestBin = Int32.MaxValue;
+
+                if (_store.Count == 0) {
+                    //Load items
+                    ((XmlElement)doc.GetElementsByTagName("Form")[0]).SetAttribute("Engine", "CATEngine3");
+                    items = doc.GetElementsByTagName("Item");
+
+
+                    //Get form CAT properties
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='IRTModel']") != null)) {
+                        _IRTModel = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='IRTModel']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing IRTModel value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='SelectionMethod']") != null)) {
+                        _SelectionMethod = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='SelectionMethod']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing SelectionMethod value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MinNumItems']") != null)) {
+                        _MinNumItems = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='MinNumItems']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing MinNumItems value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxNumItems']") != null)) {
+                        _MaxNumItems = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxNumItems']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing MaxNumItems value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxStdErr']") != null)) {
+                        _MaxStdErr = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxStdErr']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing MaxStdErr value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='SelectionGroupSize']") != null)) {
+                        _SelectionGroupSize = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='SelectionGroupSize']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing SelectionGroupSize value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='LogisticScaling']") != null)) {
+                        _LogisticScaling = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='LogisticScaling']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing LogisticScaling value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='DistMean']") != null)) {
+                        _PriorDistributionMean = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='DistMean']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if ((_IRTModel == (int)IRTModelType.GradedResponseModel) || (_IRTModel == (int)IRTModelType.GeneralizedPartialCreditModel)) {
+                            throw new ApplicationException("missing DistMean value. ");
+                        }
+                        else {
+                            _PriorDistributionMean = -1.0;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='DistStdDev']") != null)) {
+                        _PriorDistributionStdDev = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='DistStdDev']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if ((_IRTModel == (int)IRTModelType.GradedResponseModel) || (_IRTModel == (int)IRTModelType.GeneralizedPartialCreditModel)) {
+                            throw new ApplicationException("missing DistStdDev value. ");
+                        }
+                        else {
+                            _PriorDistributionStdDev = -1.0;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MinNumStradaptive']") != null)) {
+                        _MinNumStradaptive = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='MinNumStradaptive']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if (_SelectionMethod == (int)SelectionMethodType.StradaptiveWithMaximumInformation) {
+                            throw new ApplicationException("missing MinNumStradaptive value. ");
+                        }
+                        else {
+                            _MinNumStradaptive = -1;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='NoiseRange']") != null)) {
+                        _NoiseRange = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='NoiseRange']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if (((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) && (_SelectionMethod == (int)SelectionMethodType.MaximumInformationWithNoise)) {
+                            throw new ApplicationException("missing NoiseRange value. ");
+                        }
+                        else {
+                            _NoiseRange = 0.0;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='DefaultBin']") != null)) {
+                        _DefaultBin = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='DefaultBin']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                            throw new ApplicationException("missing DefaultBin value. ");
+                        }
+                        else {
+                            _DefaultBin = -1;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxStepChange']") != null)) {
+                        _MaxStepChange = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxStepChange']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                            throw new ApplicationException("missing MaxStepChange value. ");
+                        }
+                        else {
+                            _MaxStepChange = 0.0;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxNumIterations']") != null)) {
+                        _MaxNumIterations = Convert.ToInt32(FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxNumIterations']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                            throw new ApplicationException("missing MaxNumIterations value. ");
+                        }
+                        else {
+                            _MaxNumIterations = 0;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='Convergence']") != null)) {
+                        _Convergence = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='Convergence']").Attributes["Value"].Value);
+                    }
+                    else {
+                        if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                            throw new ApplicationException("missing Convergence value. ");
+                        }
+                        else {
+                            _Convergence = 0.0;
+                        }
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MinTheta']") != null)) {
+                        MinTheta = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='MinTheta']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing MinTheta value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxTheta']") != null)) {
+                        MaxTheta = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='MaxTheta']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing MaxTheta value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='ThetaIncrement']") != null)) {
+                        ThetaIncrement = Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Property[@Name='ThetaIncrement']").Attributes["Value"].Value);
+                    }
+                    else {
+                        throw new ApplicationException("missing ThetaIncrement value. ");
+                    }
+
+                    if ((FormParams.SelectSingleNode("/Calibration/Property[@Name='FirstItem']") != null)) {
+                        _FirstItem = (FormParams.SelectSingleNode("/Calibration/Property[@Name='FirstItem']").Attributes["Value"].Value).ToUpper().Trim();
+                    }
+                    else {
+                        _FirstItem = String.Empty;
+                    }
+
+                    if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                        if ((doc.GetElementsByTagName("Form")[0].Attributes["ScreenItem"]) != null) {
+                            if (!(int.TryParse((doc.GetElementsByTagName("Form")[0].Attributes["ScreenItem"]).Value, out _InitialBin))) {
+                                _InitialBin = _DefaultBin;
+                            }
+                        }
+                        else {
+                            _InitialBin = _DefaultBin;
+                        }
+
+                    }
+
+
+                    //Get item CAT parameters
+                    CATitems = FormParams.GetElementsByTagName("Item");
+
+                    //Item CAT parameters should have same number of items as the main Item doc
+                    //if (items.Count != CATitems.Count) {
+                    //	_message += "Error (CATEngine.loadItems): CAT items don't match Form items\n";
+                    //return false;
+                    //}
+
+                    _position = 0;
+
+                    for (int i = 0; i < items.Count; i++) {
+
+                        sw = new StringWriter();
+                        xw = new XmlTextWriter(sw);
+                        FormItemOID = items[i].Attributes["FormItemOID"].Value.ToUpper();
+
+                        XmlNode CATitem2 = FormParams.SelectSingleNode("/Calibration/Item[@FormItemOID='" + FormItemOID + "']");
+
+                        // Don't load items without parameters
+                        if (CATitem2 == null) {
+                            continue;
+                        }
+                        else {
+                            counter++;
+                        }
+
+                        _ItemIDs.Add(FormItemOID, counter);
+
+                        if (String.IsNullOrEmpty(items[i].Attributes["ID"].Value) && !WithHeader) {
+                            continue;
+                        }
+
+                        //Check if item already has a response
+                        if (!String.IsNullOrEmpty(((XmlElement)items[i]).GetAttribute("Response"))) {
+                            _position++;
+                            _IsResume = true;
+                            arItemsAvailable.Add(0);
+                        }
+                        else {
+                            arItemsAvailable.Add(1);
+                        }
+
+                        ((XmlElement)items[i]).SetAttribute("Position", (i + 1).ToString());
+                        items[i].WriteTo(xw);
+
+                        //Item
+                        _store.Add(sw.ToString());
+                        //Responses
+                        ItemResponseIDs = new Hashtable();
+
+                        //responses = doc.SelectNodes("/Form/Items/Item[@FormItemOID='" + FormItemOID + "']/Elements/Element[@ElementType='ResponseSet']/Mappings/Map");
+                        responses = doc.SelectNodes("/Form/Item[@FormItemOID='" + FormItemOID + "']/descendant::Map");
+
+                        bool adjustPatientResponse = false;
+                        int lowestValue = Int32.MaxValue;
+                        int k = 0;
+                        foreach (XmlNode n in responses) {
+                            k++;
+                            ItemResponseOID = n.Attributes["ItemResponseOID"].Value.ToUpper();
+
+                            int description;
+
+                            //Expected types: int = response "score"; Guid.Empty = skipped response (don't add to hashtable)
+                            //Assumes consecutive description values
+                            if (int.TryParse(n.Attributes["Position"].Value, out description)) {
+                                //description--;  // Assume "Description" is base-1 list -- !!! CAN'T DO THIS: Description CAN be zero or start at any other number
+
+                                //Note: Collapsed categories will have different ItemResponseOID but same description
+                                ItemResponseIDs.Add(ItemResponseOID, description);
+
+                                if (description < lowestValue) {
+                                    lowestValue = description;
+                                }
+                            }
+                            else {
+                                description = -1;  // skipped or invalid
+                            }
+
+                            //Check if item already has patient response
+                            if (((XmlElement)items[i]).GetAttribute("ItemResponseOID").ToUpper() == ItemResponseOID) {
+                                //Skipped item has empty GUID for ResponseOID
+                                if (Guid.Empty.ToString() == items[i].Attributes["Response"].Value) {
+                                    _ItemsSkipped.Add(counter);
+                                    _NumSkippedItems++;
+                                }
+
+                                _ItemsAsked.Add(counter);
+
+                                //Note: k is the array index, not the collapsed value
+                                //_Responses.Add(k);
+                                //Note: Calculations later need the category value to properly account for collapsed categories
+                                _Responses.Add(description);
+
+                                adjustPatientResponse = true;
+                            }
+                        }
+
+                        //If the lowest description value is not zero then adjust descriptions to start at zero
+                        //Note: The CAT parameter file uses StepOrder for this (corresponds to "description" here) and is automatically forced to start at zero
+                        if (lowestValue != 0) {
+                            //Patient response
+                            if (adjustPatientResponse) {
+                                _Responses[_Responses.Count - 1] = (int)_Responses[_Responses.Count - 1] - lowestValue;
+                            }
+
+                            //All item responses
+                            Hashtable ht = new Hashtable();
+                            foreach (string OID in ItemResponseIDs.Keys) {
+                                ht[OID] = (int)ItemResponseIDs[OID] - lowestValue;
+                            }
+                            ItemResponseIDs = ht;
+                        }
+
+                        //Note: Array location of _ResponseIDs = array location of corresponding _ItemIDs
+                        _ResponseIDs.Add(counter, ItemResponseIDs);	  //_ResponseIDs.Add(i,ItemResponseIDs);
+
+                        //CAT parameters
+                        CATitem = FormParams.SelectSingleNode("/Calibration/Item[@FormItemOID='" + FormItemOID + "']");
+
+                        //Item Discrimination value (slope or A)
+                        if (CATitem.Attributes["A_GRM"] != null) {
+                            arDisc.Add(Convert.ToDouble(CATitem.Attributes["A_GRM"].Value));
+                        }
+                        else if (CATitem.Attributes["A_PCM"] != null) {
+                            arDisc.Add(Convert.ToDouble(CATitem.Attributes["A_PCM"].Value));
+                        }
+                        else if (CATitem.Attributes["Slope"] != null) {
+                            arDisc.Add(Convert.ToDouble(CATitem.Attributes["Slope"].Value));
+                        }
+                        else {
+                            //Rasch or 1PL
+                            arDisc.Add(1);
+                        }
+
+                        //Item Difficulty value (B)
+                        if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                            if (CATitem.Attributes["Difficulty"] == null) {
+                                throw new ApplicationException("missing item Difficulty value. ");
+                            }
+                            else {
+                                liDiff.Add(Convert.ToDouble(CATitem.Attributes["Difficulty"].Value));
+                            }
+                        }
+
+                        //Item Bin assignment (BIN)
+                        if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                            if (CATitem.Attributes["Bin"] == null) {
+                                throw new ApplicationException("missing item Bin value. ");
+                            }
+                            else {
+                                liBin.Add(Convert.ToInt32(CATitem.Attributes["Bin"].Value));
+                                if (liBin[liBin.Count - 1] < lowestBin) {
+                                    lowestBin = liBin[liBin.Count - 1];
+                                }
+                            }
+                        }
+
+                        //Category boundary values
+                        arItemCBV = new ArrayList();
+                        ItemResponseIDs = new Hashtable();
+
+                        //Position loading of Threshold based on Value
+                        //Assumes that the category boundary values are always in the correct order in the XML document
+                        j = 1;
+                        foreach (XmlNode n in CATitem.SelectNodes("Map")) {
+                            //Note: j = number of categories, or one less than the number of category boundary values
+                            int desc;
+                            //Check for non-integer step order (might happen with skip or invalid responses)
+                            if (int.TryParse(n.Attributes["StepOrder"].Value, out desc)) {
+                                //This takes into account collapsed categories
+                                arItemCBV.Add(Convert.ToDouble(n.Attributes["Value"].Value));
+                                j++;
+                            }
+                        }
+
+                        //Position loading of Threshold based on ordinal position
+                        //Does not assume that the category boundary values are always in the correct order in the XML document
+                        //for (j=1; j<=CATitem.SelectNodes("Map").Count; j++) {
+                        //  arItemCBV.Add(Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Item[@FormItemOID='" + FormItemOID + "']/Map[@StepOrder='" + j + "']").Attributes["Value"].Value));
+                        //	arItemCBV.Add(Convert.ToDouble(FormParams.SelectSingleNode("/Calibration/Item[@FormItemOID='" + FormItemOID + "']/Map[@Property='CB" + j + "']").Attributes["Value"].Value));
+                        //}
+
+                        arCBV.Add((double[])arItemCBV.ToArray(typeof(double)));
+                        //Number of categories is one more than the number of category boundary values: ending value from FOR loop
+                        arNumCat.Add(j);
+                        if (j > _MaxCategories) {
+                            _MaxCategories = j;
+                        }
+
+                    }
+
+                    //If the lowest bin number is not zero then adjust bins to start at zero
+                    if (lowestBin != 0) {
+                        //Initial Bin
+                        _InitialBin = _InitialBin - lowestBin;
+
+                        //All bins
+                        for (int k=0; k < liBin.Count; k++) {
+                            liBin[k] = liBin[k] - lowestBin;
+                        }
+                    }
+
+
+                    _DiscriminationValues = (double[])arDisc.ToArray(typeof(double));
+                    _Difficulty = liDiff.ToArray();
+                    _Bin = liBin.ToArray();
+                    _CategoryBoundaryValues = (double[][])arCBV.ToArray(typeof(double[]));
+                    _NumCategoriesByItem = (int[])arNumCat.ToArray(typeof(int));
+                    _ItemsAvailable = (int[])arItemsAvailable.ToArray(typeof(int));
+
+                    _NumTotalItems = _ItemIDs.Count;
+
+                    _BinAverages = Util.CategoryAverages(liBin, liDiff);
+                    _NumBins = _BinAverages.Count;
+
+                    if ((_IRTModel == (int)IRTModelType.WideRange1PL) || (_IRTModel == (int)IRTModelType.WideRange2PL)) {
+                        liDiff.Sort(0, liDiff.Count - 1, null);
+                        _MinDifficulty = liDiff[0];
+                        _MaxDifficulty = liDiff[liDiff.Count - 1];
+                    }
+
+                    //Check if all items have been used
+                    if (_position == _store.Count) {
+                        _CriteriaMet = true;
+                        _IsCompleted = true;
+                    }
+
+                    //Store Document Shell
+                    XmlNodeList _collection = doc.GetElementsByTagName("Item");
+                    for(int i = _collection.Count - 1; i >= 0; i--) {
+                      XmlNode node = _collection[i];
+                      node.ParentNode.RemoveChild(node);
+                    }
+
+                    StringWriter sw2 = new StringWriter();
+                    XmlTextWriter xw2 = new XmlTextWriter(sw2);
+                    doc.WriteTo(xw2);
+                    _form = sw2.ToString();
+
+
+                    AreItemsLoaded = true;
+                }
+
+            return AreItemsLoaded;
+        }
+
+
+        /// <summary>
+        /// Gets the current item.
+        /// </summary>
+        /// <returns>XML document containing the current item.</returns>
+        public XmlDocument getCurrentItem()
+        {
+
+            XmlDocument doc = new XmlDocument();
+
+                int ItemIndex;
+                XmlDocumentFragment docFrag;
+                XmlNode deep;
+                XmlNode form;
+
+                //check if no items available or if done
+                int NumItemsAvailable = (int)Util.ArraySum(_ItemsAvailable);
+
+                if ((_finished) || (NumItemsAvailable == 0) || (_CriteriaMet == true)) {
+
+                    return null;
+                }
+
+                if (!_Initialized) {
+
+                    //Prepare probability matrix
+                    switch (_IRTModel) {
+                        case (int)IRTModelType.GradedResponseModel:
+                            PrepareProbabilityInfoGRM();
+                            break;
+                        case (int)IRTModelType.GeneralizedPartialCreditModel:
+                            PrepareProbabilityInfoGPCM();
+                            break;
+                        case (int)IRTModelType.WideRange1PL:
+                        case (int)IRTModelType.WideRange2PL:
+                            _CurrentBin = _InitialBin;
+                            _Theta = _BinAverages[_CurrentBin];
+                            break;
+                        default:
+                            break;
+                    }
+
+                    _Initialized = true;
+                }
+
+                if (_NumTotalItems == NumItemsAvailable) {
+                    //First item:
+                    //if pre-selected first item, 
+                    if (!(String.IsNullOrEmpty(_FirstItem))) {
+                        //Check if the _FirstItem OID exists in the Item list
+                        if (_ItemIDs.ContainsKey(_FirstItem)) {
+
+                            ItemIndex = (int)_ItemIDs[_FirstItem];
+
+                            //get item from the document store
+                            doc.LoadXml(_form);
+                            docFrag = doc.CreateDocumentFragment();
+                            docFrag.InnerXml = (String)_store[ItemIndex];
+                            deep = docFrag.CloneNode(true);
+                            doc.GetElementsByTagName("Form")[0].AppendChild(doc.ImportNode(deep, true));
+
+
+                            return doc;
+                        }
+                    }
+                }
+
+
+                int i;
+                int rnd;
+                double[] CatInfo = new double[_NumTotalItems];
+
+                //Execute item selection method
+                switch (_IRTModel) {
+                    case (int)IRTModelType.GradedResponseModel:
+                    case (int)IRTModelType.GeneralizedPartialCreditModel:
+                        CatInfo = CalcLWInfo();
+                        /*
+				        switch ( _SelectionMethod ) {
+					        case (int)SelectionMethodType.MaximumLikelihoodWeightedInformation:
+						        CatInfo = CalcLWInfo();
+						        break;
+					        case (int)SelectionMethodType.MaximumPosteriorWeightedInformation:
+						        //The only difference between Posterior and Likelihood methods is initialization, handled in the InitializeLikelihood function
+						        CatInfo = CalcLWInfo();
+						        break;
+					        //case (int)SelectionMethodType.MaximumFisherInformation:
+					        //	break;
+					        //case (int)SelectionMethodType.MaximumExpectedInformation:
+					        //	break;
+					        //case (int)SelectionMethodType.MaximumExpectedPosteriorWeightedInformation:
+					        //	break;
+					        //case (int)SelectionMethodType.MinimumExpectedPosteriorVariance:
+					        //	break;
+					        //case (int)SelectionMethodType.RandomSelection:
+					        //	break;
+					        //case (int)SelectionMethodType.KnownOrExternalTheta:
+					        //	break;
+					        default:
+						        CatInfo = CalcLWInfo();
+						        break;
+				        }
+                        */
+                        break;
+
+                    case (int)IRTModelType.WideRange1PL:
+                    case (int)IRTModelType.WideRange2PL:
+                        CatInfo = WideRangeItemValues(_Theta, _CurrentBin);
+
+                        break;
+
+                    default:
+                        break;
+
+                }
+
+                //Eliminate used items
+                CatInfo = Util.MatrixMultiply(CatInfo, _ItemsAvailable);
+
+                //Sort CatInfo in ascending order
+                //Allows non-unique CatInfo double values; SortedList doesn't allow this
+                List<KeyValuePair<double,int>> ItemList = new List<KeyValuePair<double, int>>();
+
+                for (i = 0; i < _NumTotalItems; i++) {
+                    //Don't add zeroes: these are eliminated items
+                    if (CatInfo[i] != 0) {
+                        ItemList.Add(new KeyValuePair<double,int>(CatInfo[i], i));
+                    }
+                }
+                ItemList.Sort(new Util.KVPDoubleIntComparer());
+
+                //Use C# Random instead of Util.RandomNumber to maintain compatibility with the R version of the code
+                rnd = _RandomNumber.Next(_SelectionGroupSize - 1);
+                //rnd = Util.RandomNumber.Next(_SelectionGroupSize - 1);
+
+                //Get index of highest item (randomly selected from the top _SelectionGroupSize number of items)
+                ItemIndex = ItemList[ItemList.Count - 1 - rnd].Value;
+                
+
+                /*
+                //Sort CatInfo (automatically ascending order)
+                SortedList Items = new SortedList();
+
+                for (i = 0; i < _NumTotalItems; i++) {
+                    //Don't add zeroes: these are eliminated items
+                    if (CatInfo[i] != 0) {
+                        Items.Add(CatInfo[i], i);
+                    }
+                }
+                Items.TrimToSize();
+
+                rnd = _RandomNumber.Next(_SelectionGroupSize - 1);
+
+                //Get index of highest item (randomly selected from the top _SelectionGroupSize number of items)
+                ItemIndex = (int)Items[Items.GetKey(Items.Count - 1 - rnd)];
+                */
+
+                //Get item from the document store
+                doc.LoadXml(_form);
+                docFrag = doc.CreateDocumentFragment();
+                docFrag.InnerXml = (String)_store[ItemIndex];
+                ((XmlElement)doc.GetElementsByTagName("Form")[0]).SetAttribute("Theta", ((decimal)_Theta).ToString());
+                ((XmlElement)doc.GetElementsByTagName("Form")[0]).SetAttribute("StdError", ((decimal)_StdError).ToString());
+                doc.GetElementsByTagName("Form")[0].AppendChild(doc.ImportNode(docFrag, true));
+            return doc;
+        }
+
+
+        /// <summary>
+        /// Updates the document store with the changed node.
+        /// </summary>
+        /// <param name="node">The node.</param>
+        public void updateNode(XmlNode node)
+        {
+
+                string FormItemOID;
+                string ItemResponseOID;
+                int ItemIndex;
+                int ResponseIndex;
+                XmlAttribute attrib;
+                int NumAnsweredItems;
+                bool skipped = false;
+                double[] QAProbability;
+
+                //Get the index of the item and response
+                FormItemOID = node.Attributes["FormItemOID"].Value.ToUpper();
+                ItemResponseOID = node.Attributes["ItemResponseOID"].Value.ToUpper();
+
+                ItemIndex = (int)_ItemIDs[FormItemOID];
+                
+                //Skipped response
+                if (((XmlElement)node).GetAttribute("ItemResponseOID").ToUpper() == Guid.Empty.ToString().ToUpper()) {
+                    skipped = true;
+                    _NumSkippedItems++;
+                    _ItemsSkipped.Add(ItemIndex);
+                    ResponseIndex = -1;
+                }
+                else {
+                    //Note: this takes into account a collapsed response category
+                    ResponseIndex = (int)((Hashtable)_ResponseIDs[ItemIndex])[ItemResponseOID];
+                }
+
+                _ItemsAsked.Add(ItemIndex);
+                //Note: this is the collapsed value if category is collapsed; -1 if skipped or invalid
+                _Responses.Add(ResponseIndex);
+                _ItemsAvailable[ItemIndex] = 0;
+                NumAnsweredItems = _ItemsAsked.Count - _NumSkippedItems;
+
+                //If this is a skip response, don't do any calculations.
+                if (!skipped) {
+                    // if ((_IRTModel == (int)IRTModelType.GradedResponseModel) || (_IRTModel == (int)IRTModelType.GeneralizedPartialCreditModel)) {
+                    //     QAProbability = new double[_Probability.GetLength(0)];
+                    // }
+
+                    if (!_Initialized) {
+                        switch (_IRTModel) {
+                            case (int)IRTModelType.GradedResponseModel:
+                                PrepareProbabilityInfoGRM();
+                                break;
+                            case (int)IRTModelType.GeneralizedPartialCreditModel:
+                                PrepareProbabilityInfoGPCM();
+                                break;
+                            case (int)IRTModelType.WideRange1PL:
+                            case (int)IRTModelType.WideRange2PL:
+                                _NumCorrectItems = 0;
+                                for (int i = 0; i < _Responses.Count-2; i++ ) {
+                                    _NumCorrectItems = _NumCorrectItems + ResponseIndex;
+                                }
+                                break;
+                            default: //Graded Response Model
+                                //PrepareProbabilityInfoGRM();
+                                break;
+                        }
+                        _Initialized = true;
+                    }
+
+                    switch (_IRTModel) {
+                        case (int)IRTModelType.GradedResponseModel:
+                        case (int)IRTModelType.GeneralizedPartialCreditModel:
+                            //get probability slice
+                            QAProbability = Util.MatrixSlice1D(_Probability, Util.DimensionType.Row, ItemIndex, Util.DimensionType.Column, ResponseIndex, Util.DimensionType.Depth);
+                            //new likelihood
+                            _Likelihood = Util.MatrixMultiply(_Likelihood, QAProbability);
+
+                            //estimate new theta
+                            CalcThetaEstimate();
+                            break;
+
+                        case (int)IRTModelType.WideRange1PL:
+                        case (int)IRTModelType.WideRange2PL:
+                            //Note: ResponseIndex is the same as the item score: 0 (incorrect) or 1 (correct)
+                            _NumCorrectItems = _NumCorrectItems + ResponseIndex;
+                            
+                            if ((ResponseIndex == 1) && (_CurrentBin < (_NumBins - 1))) {
+                                _CurrentBin++;
+                            }
+                            else if ((ResponseIndex == 0) && (_CurrentBin > 0)) {
+                                _CurrentBin--;
+                            }
+
+                            if ((_NumCorrectItems < _ItemsAsked.Count) && (_NumCorrectItems > 0)) {
+                                CalcMaximumLikelihoodEstimate();
+
+                                if (Math.Abs(_MaximumLikelihoodTheta - _Theta) > _MaxStepChange) {
+                                    int sign = (_MaximumLikelihoodTheta - _Theta < 0) ? -1 : 1;
+                                    _Theta = _Theta + sign * _MaxStepChange;
+                                }
+                                else {
+                                    _Theta = _MaximumLikelihoodTheta;
+                                    _StdError = _MaximumLikelihoodError;
+                                }
+                            }
+                            else {
+                                _Theta = _BinAverages[_CurrentBin];
+                            }
+
+                            break;
+                    }
+
+                    //store histories
+                    _ThetaHistory.Add(_Theta);
+                    _StdErrorHistory.Add(_StdError);
+                    _LikelihoodHistory.Add(_LikelihoodEstimate);
+                }
+
+                //If skip response selected then only check if MaxNumItems has been reached
+                //Need to subtract global skip item counter from ItemsAsked counter AND MaxNumItems count and then compare
+                //Check if stopping criterion is met or asked sufficient questions
+                //if ((_ItemsAsked.Count >= _MaxNumItems) || ((_StdError <= _MaxStdErr) && (_ItemsAsked.Count >= _MinNumItems))) {
+                if ((NumAnsweredItems >= _MaxNumItems) || ((_StdError <= _MaxStdErr) && (NumAnsweredItems >= _MinNumItems)) || (_ItemsAsked.Count >= _NumTotalItems)) {
+                    _CriteriaMet = true;
+                    _finished = true;
+                }
+
+                //No new theta or standard error for skipped items
+                if (!skipped) {
+                    //add theta attribute
+                    attrib = node.OwnerDocument.CreateAttribute("Theta");
+                    attrib.Value = _Theta.ToString();
+                    node.Attributes.SetNamedItem(attrib);
+
+                    //add standard error attribute
+                    attrib = node.OwnerDocument.CreateAttribute("StdError");
+                    attrib.Value = _StdError.ToString();
+                    node.Attributes.SetNamedItem(attrib);
+                }
+
+                //update store
+                StringWriter sw = new StringWriter();
+                XmlTextWriter xw = new XmlTextWriter(sw);
+                node.WriteTo(xw);
+                _store[ItemIndex] = sw.ToString();
+        }
+
+
+        /// <summary>
+        /// Gets the previous item.
+        /// </summary>
+        /// <returns>XML document with the previous item</returns>
+        /// <remarks>Not valid for CAT, empty document returned.</remarks>
+        public XmlDocument getPreviousItem()
+        {
+            //_Recalculate = true;
+            return new XmlDocument();
+        }
+
+
+        /// <summary>
+        /// Gets the next item.
+        /// </summary>
+        /// <returns>XML document containing the next item.</returns>
+        public XmlDocument getNextItem()
+        {
+            _position++;
+            return getCurrentItem();
+        }
+
+
+        /// <summary>
+        /// Increments the position.
+        /// </summary>
+        /// <remarks>Not used by CAT, position incremented at getNextItem</remarks>
+        public void incrementPosition()
+        {
+        }
+
+
+        /// <summary>
+        /// Decrements the position.
+        /// </summary>
+        /// <remarks>Not valid for CAT, does nothing.</remarks>
+        public void decrementPosition()
+        {
+            //_Recalculate = true;
+        }
+
+
+        /// <summary>
+        /// Rolls back the position.
+        /// </summary>
+        /// <remarks>Not used by CAT, does nothing.</remarks>
+        public void rollbackPosition()
+        {
+            //_Recalculate = true;
+        }
+
+
+        #endregion
+
+        #region Inherited properties
+
+        /// <summary>
+        /// Has the user now finished this form? <c>true</c> if yes, <c>false</c> if not.
+        /// </summary>
+        private bool _finished;
+        /// <summary>
+        /// Gets a value indicating if the user has now finished this form.
+        /// </summary>
+        /// <value><c>true</c> if finished; otherwise, <c>false</c>.</value>
+        public bool finished
+        {
+            get { return _finished; }
+            set { _finished = value; }
+        }
+
+        /// <summary>
+        /// Has the user completed this form in the past?  <c>true</c> if yes, <c>false</c> if not.
+        /// </summary>
+        private bool _IsCompleted;
+        /// <summary>
+        /// Gets a value indicating if this form has was completed in the past.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this form has been completed; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsCompleted
+        {
+            get { return _IsCompleted; }
+        }
+
+        /// <summary>
+        /// Is the user resuming a previously started form?  <c>true</c> if yes, <c>false</c> if not.
+        /// </summary>
+        private bool _IsResume;
+        /// <summary>
+        /// Gets a value indicating whether the user is resuming a previously started form.
+        /// </summary>
+        /// <value><c>true</c> if resuming; otherwise, <c>false</c>.</value>
+        public bool IsResume
+        {
+            get { return _IsResume; }
+        }
+
+        /// <summary>
+        /// Integer containing the current position number on the form.
+        /// </summary>
+        private int _currentPosition;
+        /// <summary>
+        /// Gets or sets the current position.
+        /// </summary>
+        /// <value>The current position.</value>
+        public int currentPosition
+        {
+            get { return _position; }
+            set
+            {
+                _position = value;
+                _currentPosition = value;
+            }
+        }
+
+        /// <summary>
+        /// Integer containing the previous position number on the form.
+        /// </summary>
+        private int _previousPosition;
+        /// <summary>
+        /// Gets or sets the previous position.
+        /// </summary>
+        /// <value>The previous position.</value>
+        public int previousPosition
+        {
+            get { return _position - 1; }
+            set { _previousPosition = value; }
+        }
+
+        /// <summary>
+        /// Gets the total number of items.
+        /// </summary>
+        /// <value>The total number of items.</value>
+        public int TotalItems
+        {
+            get { return _NumTotalItems; }
+        }
+
+        /// <summary>
+        /// String containing a message to send back to the caller,
+        /// </summary>
+        private string _message;
+        /// <summary>
+        /// Gets or sets a message to send back to the caller.
+        /// </summary>
+        /// <value>The message.</value>
+        public string message
+        {
+            get { return _message; }
+            set { _message = value; }
+        }
+
+        /// <summary>
+        /// String containing the stored procedure name used to get the form and item parameters.
+        /// </summary>
+        private string _paramPROC;
+        /// <summary>
+        /// Gets the stored procedure name used to get the form and item parameters.
+        /// </summary>
+        /// <value>The stored procedure name.</value>
+        public string paramPROC
+        {
+            get { return _paramPROC; }
+        }
+
+        #endregion
+
+        #region New private (formerly public) properties
+
+
+        //theta.history, theta.cat
+        /// <summary>
+        /// Arraylist containing the theta history.
+        /// </summary>
+        private ArrayList _ThetaHistory;
+        /// <summary>
+        /// Gets the theta history.
+        /// </summary>
+        /// <value>The Theta history.</value>
+        public double[] ThetaHistory
+        {
+            get { return (double[])_ThetaHistory.ToArray(typeof(double)); }
+        }
+
+        //sem.history, sem.cat
+        /// <summary>
+        /// Arraylist containing the standard error history.
+        /// </summary>
+        private ArrayList _StdErrorHistory;
+        /// <summary>
+        /// Gets the standard error history.
+        /// </summary>
+        /// <value>The standard error history.</value>
+        public double[] StdErrorHistory
+        {
+            get { return (double[])_StdErrorHistory.ToArray(typeof(double)); }
+        }
+
+        //likelihood.matrix
+        /// <summary>
+        /// Arraylist containing the likelihood history.
+        /// </summary>
+        private ArrayList _LikelihoodHistory;
+        /// <summary>
+        /// Gets the likelihood history.
+        /// </summary>
+        /// <value>The likelihood history.</value>
+        public double[][] LikelihoodHistory
+        {
+            get { return (double[][])_LikelihoodHistory.ToArray(typeof(double[])); }
+        }
+
+
+        #endregion
+
+        #region Private properties
+
+        /// <summary>
+        /// String containing the FormItemOID of the first item to be selected (pre-selected rather than calculated).
+        /// </summary>
+        private string _FirstItem;
+
+        //minTheta
+        /// <summary>
+        /// Double containing the minimum theta value.
+        /// </summary>
+        private double _MinTheta;
+        /// <summary>
+        /// Gets or sets the minimum theta value.
+        /// </summary>
+        /// <value>The minimum theta.</value>
+        private double MinTheta
+        {
+            get { return _MinTheta; }
+            set
+            {
+                _MinTheta = value;
+                InitializeQuadrature();
+                _PriorDistribution = Util.SetNormalDistribution(_QuadraturePoints, _PriorDistributionMean, _PriorDistributionStdDev);
+                InitializeLikelihood();
+            }
+        }
+
+        //maxTheta
+        /// <summary>
+        /// Double containing the maximum theta value.
+        /// </summary>
+        private double _MaxTheta;
+        /// <summary>
+        /// Gets or sets the maximum theta value.
+        /// </summary>
+        /// <value>The maximum theta value.</value>
+        private double MaxTheta
+        {
+            get { return _MaxTheta; }
+            set
+            {
+                _MaxTheta = value;
+                InitializeQuadrature();
+                _PriorDistribution = Util.SetNormalDistribution(_QuadraturePoints, _PriorDistributionMean, _PriorDistributionStdDev);
+                InitializeLikelihood();
+            }
+        }
+
+        //inc
+        /// <summary>
+        /// Double containing the theta value increment.
+        /// </summary>
+        private double _ThetaIncrement;
+        /// <summary>
+        /// Gets or sets the theta value increment.
+        /// </summary>
+        /// <value>The theta value increment.</value>
+        private double ThetaIncrement
+        {
+            get { return _ThetaIncrement; }
+            set
+            {
+                _ThetaIncrement = value;
+                InitializeQuadrature();
+                _PriorDistribution = Util.SetNormalDistribution(_QuadraturePoints, _PriorDistributionMean, _PriorDistributionStdDev);
+                InitializeLikelihood();
+            }
+        }
+
+        /// <summary>
+        /// Integer containing the item currently presented. The position starts at zero and increments by one 
+        /// for each item as it is presented.
+        /// </summary>
+        private int _position;
+
+        /// <summary>
+        /// Arraylist containing each item as an XML node.
+        /// </summary>
+        private ArrayList _store;
+
+        /// <summary>
+        /// String containing a shell of the the assessment form in XML format. Does not contain any items.
+        /// </summary>
+        private string _form;
+
+        /// <summary>
+        /// Integer containing the number of items available to administer. Does not incude items that have already been presented. 
+        /// Stores 1 if item is available, 0 if not.
+        /// </summary>
+        private int[] _ItemsAvailable;
+
+        /// <summary>
+        /// Hashtable containing the FormItemOIDs and their order in the form.<br/>
+        /// Key: FormItemID (GUID)<br/>
+        /// Value: array index of item (int)
+        /// </summary>
+        private Hashtable _ItemIDs;
+
+        /// <summary>
+        /// Hashtable containing the ResponseItemOIDs and their order in the form and in each item.<br/>
+        /// Key: array index of item (int)<br/>
+        /// Value: Hashtable of ItemResponseIDs for this item<br/>
+        /// -----<br/>
+        /// ItemResponseIDs hashtable:<br/>
+        /// Key: ItemResponseID (GUID)<br/>
+        /// Value: array index of response (int)
+        /// </summary>
+        private Hashtable _ResponseIDs;
+
+        /// <summary>
+        /// Arraylist containing the array indexes of items presented to the user
+        /// </summary>
+        private ArrayList _ItemsAsked;
+
+        /// <summary>
+        /// Arraylist containing the array indexes of items skipped by the user
+        /// </summary>
+        private ArrayList _ItemsSkipped;
+
+        /// <summary>
+        /// Arraylist containing the array indexes of responses from the user
+        /// </summary>
+        private ArrayList _Responses;
+
+        //maxCat
+        /// <summary>
+        /// Integer containing the maximum number of response categories.
+        /// </summary>
+        private int _MaxCategories;
+
+        //ni
+        /// <summary>
+        /// Integer containing the total number of items.
+        /// </summary>
+        private int _NumTotalItems;
+
+        /// <summary>
+        /// Integer containing the total number of skipped items.
+        /// </summary>
+        private int _NumSkippedItems;
+
+        /// <summary>
+        /// Integer containing the total number of correctly answered items.
+        /// </summary>
+        private int _NumCorrectItems;
+
+        //maxNI
+        /// <summary>
+        /// Integer containing the maximum number of items to administer.
+        /// </summary>
+        private int _MaxNumItems;
+
+        //minNI
+        /// <summary>
+        /// Integer containing the minimum number of items to administer.
+        /// </summary>
+        private int _MinNumItems;
+
+        //maxSE
+        /// <summary>
+        /// Double containing the maximum allowable standard error before terminating.
+        /// </summary>
+        private double _MaxStdErr;
+
+        //topN
+        /// <summary>
+        /// Integer containing the selection group size from which the next item is selected randomly.
+        /// </summary>
+        private int _SelectionGroupSize;
+
+        //selection.method, method
+        /// <summary>
+        /// Integer containing the CAT item selection method to use.
+        /// </summary>
+        private int _SelectionMethod;
+
+        /// <summary>
+        /// Integer containing the item response theory model to use.
+        /// </summary>
+        private int _IRTModel;
+
+        /// <summary>
+        /// Integer containing the minimum numer of Stradaptive items for Wide Range CAT 
+        /// </summary>
+        private int _MinNumStradaptive;
+
+        //noiseML
+        /// <summary>
+        /// Double containing the range of noise in maximum likelihood for Wide Range CAT. The total noise is plus and minus this value (i.e., 2 * _NoiseRange).
+        /// </summary>
+        private double _NoiseRange;
+
+        /// <summary>
+        /// Integer containing the default bin to use when none is specified.
+        /// </summary>
+        private int _DefaultBin;
+
+        //maxIter
+        /// <summary>
+        /// Integer containing the maximum number of iterations to use for Wide Range CAT.
+        /// </summary>
+        private int _MaxNumIterations;
+
+        //maxStep
+        /// <summary>
+        /// Double containing the maximum step change for Wide Range CAT
+        /// </summary>
+        private double _MaxStepChange;
+
+        //crit
+        /// <summary>
+        /// Double containing the convergence criterion for Wide Range CAT
+        /// </summary>
+        private double _Convergence;
+
+        //D
+        /// <summary>
+        /// Double containing the logistic scaling constant.
+        /// </summary>
+        private double _LogisticScaling;
+
+        //start.theta, theta.current
+        /// <summary>
+        /// Double containing the current theta value.
+        /// </summary>
+        private double _Theta;
+
+        //bin.current
+        /// <summary>
+        /// Integer containing the current bin assignment.
+        /// </summary>
+        private int _CurrentBin;
+
+        //NCAT
+        /// <summary>
+        /// Integer array containing the number of response categories for each item.
+        /// </summary>
+        private int[] _NumCategoriesByItem;
+
+        //DISC
+        /// <summary>
+        /// Double array containing the discrimination values for each item.
+        /// </summary>
+        private double[] _DiscriminationValues;
+
+        //B
+        /// <summary>
+        /// Double array containing the difficulty values for each item.
+        /// </summary>
+        private double[] _Difficulty;
+
+        //minB
+        /// <summary>
+        /// Double containing the minimum difficulty
+        /// </summary>
+        private double _MinDifficulty;
+
+        //maxB
+        /// <summary>
+        /// Double containing the maximum difficulty
+        /// </summary>
+        private double _MaxDifficulty;
+
+        //mean.theta.bin
+        /// <summary>
+        /// SortedList containing the averages of each bin
+        /// </summary>
+        private SortedList<int, double> _BinAverages;
+
+        //BIN
+        /// <summary>
+        /// Integer array containing the bin assignments for each item.
+        /// </summary>
+        private int[] _Bin;
+
+        //nBin
+        /// <summary>
+        /// Integer containing the number of bins to use for Wide Range CAT.
+        /// </summary>
+        private int _NumBins;
+
+        //nBin
+        /// <summary>
+        /// Integer containing the initial bin to use for this person for Wide Range CAT.
+        /// </summary>
+        private int _InitialBin;
+
+        //CB
+        /// <summary>
+        /// Two dimensional jagged double array containing the category boundary values for each item.
+        /// </summary>
+        private double[][] _CategoryBoundaryValues;
+
+        //theta
+        /// <summary>
+        /// Double array containing the quadrature points for numerical integration
+        /// </summary>
+        private double[] _QuadraturePoints;
+
+        //nq
+        /// <summary>
+        /// Integer containing the number of quadrature points
+        /// </summary>
+        private int _NumQuadraturePoints;
+
+        //LH
+        /// <summary>
+        /// Double array containing the likelihood values for each item.
+        /// </summary>
+        private double[] _Likelihood;
+
+        //prior
+        /// <summary>
+        /// Double array containing the prior distribution of likelihood estimates.
+        /// </summary>
+        private double[] _PriorDistribution;
+
+        //prior.mean
+        /// <summary>
+        /// Double containing the prior distribution mean of likelihood estimates.
+        /// </summary>
+        private double _PriorDistributionMean;
+
+        //prior.sd
+        /// <summary>
+        /// Double containing the prior distribution standard deviation of likelihood estimates.
+        /// </summary>
+        private double _PriorDistributionStdDev;
+
+        //pp
+        /// <summary>
+        /// Three dimensional double array containing the probability values for each item.
+        /// </summary>
+        private double[, ,] _Probability;
+
+        //matrix.info
+        /// <summary>
+        /// Two dimensional double array containing the item information over each of the quadrature points.
+        /// </summary>
+        private double[,] _ItemInfoOverQuadrature;
+
+        //SEM
+        /// <summary>
+        /// Double containing the standard error estimate.
+        /// </summary>
+        private double _StdError;
+
+        //critMet
+        /// <summary>
+        /// Has the stopping criteria been met? <c>true</c> if yes, <c>false</c> if not.
+        /// </summary>
+        private bool _CriteriaMet;
+
+        /// <summary>
+        /// Should a full re-calculation from the beginning be performed?  <c>true</c> if yes, <c>false</c> if not.
+        /// </summary>
+        private bool _Recalculate;
+
+        /// <summary>
+        /// Has the probability matrix been initialized?  <c>true</c> if yes, <c>false</c> if not.
+        /// </summary>
+        private bool _Initialized;
+
+        /// <summary>
+        /// Random number generator.
+        /// </summary>
+        private Random _RandomNumber;
+
+        /// <summary>
+        /// Double array containing the latest likelihood estimates.
+        /// </summary>
+        private double[] _LikelihoodEstimate;
+
+        /// <summary>
+        /// Double array containing the Maximum Likelihood theta estimate
+        /// </summary>
+        private double _MaximumLikelihoodTheta;
+
+        /// <summary>
+        /// Double array containing the Maximum Likelihood error estimate
+        /// </summary>
+        private double _MaximumLikelihoodError;
+
+        #endregion
+
+        #region Private methods
+
+
+        /// <summary>
+        /// Initializes the quadrature point array.
+        /// </summary>
+        /// <remarks>If MinTheta is greater than MaxTheta, null value is returned. 
+        /// If ThetaIncrement is zero, null value is returned. 
+        /// This also calculates the number of quadrature points.
+        /// </remarks>
+        private void InitializeQuadrature()
+        {
+            int i;
+
+            if (_MinTheta >= _MaxTheta) {
+                _NumQuadraturePoints = 0;
+                return;
+            }
+            else if (_ThetaIncrement == 0) {
+                _NumQuadraturePoints = 0;
+                return;
+            }
+
+            //Calculate quadrature points
+            ArrayList Points = new ArrayList();
+            double pnt = _MinTheta;
+
+            //Assume 20 decimal places
+            double Pow10;
+            i = 1;
+            double OnePercent = _ThetaIncrement * 0.01;
+            do {
+                i--;
+                Pow10 = Math.Pow(10, i);
+            } while ((i > -20) && (Pow10 > OnePercent));
+            int RoundingPlace = -1 * i;
+
+
+            do {
+                Points.Add(pnt);
+                pnt = Math.Round((pnt + _ThetaIncrement), RoundingPlace);
+            } while (pnt <= _MaxTheta);
+
+            _QuadraturePoints = (double[])Points.ToArray(typeof(double));
+
+            //Calculate number of quadrature points
+            _NumQuadraturePoints = Points.Count;
+        }
+
+        /// <summary>
+        /// Initializes the likelihood array.
+        /// </summary>
+        private void InitializeLikelihood()
+        {
+            if (_NumQuadraturePoints == 0) {
+                return;
+            }
+            _Likelihood = new double[_NumQuadraturePoints];
+            for (int i = 0; i < _NumQuadraturePoints; i++) {
+                //Initialize according to likelihood method or posterior method (posterior is the default)
+                switch (_SelectionMethod) {
+                    case (int)SelectionMethodType.MaximumLikelihoodWeightedInformation:
+                        _Likelihood[i] = 1;
+                        break;
+                    case (int)SelectionMethodType.MaximumPosteriorWeightedInformation:
+                        _Likelihood[i] = _PriorDistribution[i];
+                        break;
+                    default: //MPWI
+                        _Likelihood[i] = _PriorDistribution[i];
+                        break;
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Generate matrix for category probabilities and matrix for information for items 
+        /// over quadrature points (Graded Response Model).
+        /// </summary>
+        private void PrepareProbabilityInfoGRM()
+        {
+            int qpnt;
+            int item;
+            int cat;
+            //pp<-array(0,c(nq,ni,maxCat))				//an array for probability values (nq x ni x maxCat)
+            _Probability = new double[_NumQuadraturePoints, _NumTotalItems, _MaxCategories];
+            //matrix.info<-matrix(0,nq,ni)				//a matrix for item information over theta (nq x ni)
+            _ItemInfoOverQuadrature = new double[_NumQuadraturePoints, _NumTotalItems];
+            //ps
+            double[,] CumulativeCategory;
+
+            //BEWARE Base zero/one errors
+            //for (i in 1:ni) {
+            for (item = 0; item < _NumTotalItems; item++) {
+                //ps<-matrix(0,nq,NCAT[i]+1)			//cumulative category functions
+                CumulativeCategory = new double[_NumQuadraturePoints, _NumCategoriesByItem[item] + 1];
+                for (qpnt = 0; qpnt < CumulativeCategory.GetLength(0); qpnt++) {
+                    //ps[,1]<-1
+                    CumulativeCategory[qpnt, 0] = 1;
+                    //ps[,NCAT[i]+1]<-0
+                    //CumulativeCategory[qpnt,_NumCategoriesByItem[item]] = 0; //already zero by initialization
+                }
+                //for (k in 1:(NCAT[i]-1)) {
+                for (cat = 0; cat < _NumCategoriesByItem[item] - 1; cat++) {
+                    for (qpnt = 0; qpnt < CumulativeCategory.GetLength(0); qpnt++) {
+                        //ps[,k+1]<-1/(1+exp(-D*DISC[i]*(theta-CB[i,k])))
+                        CumulativeCategory[qpnt, cat + 1] = 1 / (1 + Math.Exp((-1) * _LogisticScaling * _DiscriminationValues[item] * (_QuadraturePoints[qpnt] - _CategoryBoundaryValues[item][cat])));
+                    }
+                }
+                for (qpnt = 0; qpnt < _Probability.GetLength(0); qpnt++) {
+                    //pp[,i,1]<-1-ps[,1]
+                    _Probability[qpnt, item, 0] = 1 - CumulativeCategory[qpnt, 0];
+                    //pp[,i,NCAT[i]]<-ps[,NCAT[i]]
+                    _Probability[qpnt, item, _NumCategoriesByItem[item] - 1] = CumulativeCategory[qpnt, _NumCategoriesByItem[item] - 1];
+                }
+
+                //for (k in 1:NCAT[i]) {
+                for (cat = 0; cat < _NumCategoriesByItem[item]; cat++) {
+                    for (qpnt = 0; qpnt < _Probability.GetLength(0); qpnt++) {
+                        //pp[,i,k]=ps[,k]-ps[,k+1]
+                        _Probability[qpnt, item, cat] = CumulativeCategory[qpnt, cat] - CumulativeCategory[qpnt, cat + 1];
+                        //matrix.info[,i]<-                  matrix.info[,i]                    +         ( DISC[i]                     * ( ps[,k]                       * (1-ps[,k]                      ) - ps[,k+1]                       * (1-ps[,k+1]                      ) )   )^2 / pp[,i,k]
+                        _ItemInfoOverQuadrature[qpnt, item] = _ItemInfoOverQuadrature[qpnt, item] + Math.Pow(_DiscriminationValues[item] * (CumulativeCategory[qpnt, cat] * (1 - CumulativeCategory[qpnt, cat]) - CumulativeCategory[qpnt, cat + 1] * (1 - CumulativeCategory[qpnt, cat + 1])), 2) / _Probability[qpnt, item, cat];
+                    }
+                }
+                //For debugging:
+                //Util.WriteNumericArrayToFile("CumulativeCategory" + item.ToString() + ".txt", false, " ", CumulativeCategory);
+            }
+
+            //For debugging:
+            //Util.WriteNumericArrayToFile("ItemInfoOverQuadrature.txt", false, " ", _ItemInfoOverQuadrature);
+            /*
+            //For debugging:
+            double[,] ProbItemSlice;
+            for (int z=0; z<_Probability.GetLength(1); z++) {
+                ProbItemSlice = new double[_Probability.GetLength(0),_Probability.GetLength(2)];
+                for (int i=0; i<_Probability.GetLength(0); i++) {
+                    for (int j=0; j<_Probability.GetLength(2); j++) {
+                        ProbItemSlice[i,j] = _Probability[i,z,j];
+                    }
+                }
+                Util.WriteNumericArrayToFile("ProbItemSlice" + z.ToString() + ".txt", false, " ", ProbItemSlice);
+            }
+            */
+        }
+
+
+        /// <summary>
+        /// Generate matrix for category probabilities and matrix for information for items 
+        /// over quadrature points (Generalized Partial Credit Model).
+        /// </summary>
+        private void PrepareProbabilityInfoGPCM()
+        {
+            int qpnt;
+            int item;
+            int cat;
+
+            _Probability = new double[_NumQuadraturePoints, _NumTotalItems, _MaxCategories];  //an array for probability values
+            _ItemInfoOverQuadrature = new double[_NumQuadraturePoints, _NumTotalItems];  //a matrix for item information over theta
+
+            double[,] NumeratorProbability;  // numerators for probabilities
+            double[] DenominatorProbability; // denominators for probabilities
+            double sdsum;  // sum of category parameters
+            double[] AX;  // A component for information
+            double[] BX;  // B component for information
+
+            //BEWARE Base zero/one errors
+            for (item = 0; item < _NumTotalItems; item++) {
+
+                NumeratorProbability = new double[_NumQuadraturePoints, _NumCategoriesByItem[item]];
+                DenominatorProbability = new double[_NumQuadraturePoints];
+                sdsum = 0.0;  //initialize for the item
+                AX = new double[_NumQuadraturePoints];  //initialize for the item
+                BX = new double[_NumQuadraturePoints];  //initialize for the item
+
+                for (cat = 0; cat < _NumCategoriesByItem[item]; cat++) {
+                    if (cat > 0) {
+                        sdsum += _CategoryBoundaryValues[item][cat - 1];
+                    }
+                    for (qpnt = 0; qpnt < _NumQuadraturePoints; qpnt++) {
+                        NumeratorProbability[qpnt, cat] = Math.Exp(_LogisticScaling * _DiscriminationValues[item] * (cat * _QuadraturePoints[qpnt] - sdsum));
+                        DenominatorProbability[qpnt] += NumeratorProbability[qpnt, cat];
+                    }
+                }
+
+                for (qpnt = 0; qpnt < _Probability.GetLength(0); qpnt++) {
+                    for (cat = 0; cat < _NumCategoriesByItem[item]; cat++) {
+                        _Probability[qpnt, item, cat] = NumeratorProbability[qpnt, cat] / DenominatorProbability[qpnt];
+                        AX[qpnt] += Math.Pow(cat, 2) * _Probability[qpnt, item, cat];
+                        BX[qpnt] += cat * _Probability[qpnt, item, cat];
+                    }
+                    _ItemInfoOverQuadrature[qpnt, item] = Math.Pow(_LogisticScaling, 2) * Math.Pow(_DiscriminationValues[item], 2) * (AX[qpnt] - Math.Pow(BX[qpnt], 2));
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Calculates the theta estimate, the standard error, and the new likelihood 
+        /// given questions and their responses.
+        /// </summary>
+        //CalcEAP
+        private void CalcThetaEstimate()
+        {
+            double[] QAProbability = new double[_QuadraturePoints.Length];
+            double[] tmp = new double[_QuadraturePoints.Length];
+
+            if (_Recalculate) {
+                //initialize likelihood estimate with prior information
+                _LikelihoodEstimate = _PriorDistribution;
+
+                //for each item given so far
+                for (int i = 0; i < _ItemsAsked.Count - 1; i++) {
+                    //if skip response then don't calculate probability or update likelihood estimate
+                    if (!_ItemsSkipped.Contains((int)_ItemsAsked[i])) {
+                        QAProbability = Util.MatrixSlice1D(_Probability, Util.DimensionType.Row, (int)_ItemsAsked[i], Util.DimensionType.Column, (int)_Responses[i], Util.DimensionType.Depth);
+                        _LikelihoodEstimate = Util.MatrixMultiply(_LikelihoodEstimate, QAProbability);
+                    }
+                }
+            }
+
+            //Since this whole method should be skipped in updateNode for a skip response, don't need to skip again here, but can add a condition check anyway to be safe.
+            //For skip response we do not want to update probability, likelihood estimate, theta, or standard error
+            if (!_ItemsSkipped.Contains((int)_ItemsAsked[_ItemsAsked.Count - 1])) {
+                //new likelihood estimate
+                QAProbability = Util.MatrixSlice1D(_Probability, Util.DimensionType.Row, (int)_ItemsAsked[_ItemsAsked.Count - 1], Util.DimensionType.Column, (int)_Responses[_Responses.Count - 1], Util.DimensionType.Depth);
+                _LikelihoodEstimate = Util.MatrixMultiply(_LikelihoodEstimate, QAProbability);
+
+                //EAP<-sum(LH*theta)/sum(LH)
+                _Theta = Util.ArraySum(Util.MatrixMultiply(_LikelihoodEstimate, _QuadraturePoints)) / Util.ArraySum(_LikelihoodEstimate);
+
+                //SEM<-sqrt(sum(LH*(theta-EAP)^2)/sum(LH))
+                tmp.Initialize();
+                for (int i = 0; i < _QuadraturePoints.Length; i++) {
+                    tmp[i] = Math.Pow((_QuadraturePoints[i] - _Theta), 2);
+                }
+                _StdError = Math.Sqrt(Util.ArraySum(Util.MatrixMultiply(_LikelihoodEstimate, tmp)) / Util.ArraySum(_LikelihoodEstimate));
+            }
+
+            _Recalculate = false;
+
+        }
+
+        /// <summary>
+        /// Calculates the likelihood weighted information for all available items 
+        /// given likelihood function over quadrature points. This is the primary algorithm 
+        /// for the Maximum Likelihood Weighted Information and the Maximum Posterior 
+        /// Weighted Information CAT method.
+        /// </summary>
+        /// <returns>The likelihood weighted information for all available items.</returns>
+        //calc.LW.info
+        private double[] CalcLWInfo()
+        {
+            double[] info = new double[_Likelihood.Length];
+            double[,] ar2d = new double[_ItemInfoOverQuadrature.GetLength(0), _ItemInfoOverQuadrature.GetLength(1)];
+
+            //info<-apply(matrix.info*lk,2,sum)
+            ar2d = Util.MatrixMultiply(_ItemInfoOverQuadrature, _Likelihood);
+            info = Util.MatrixReduceBySum(ar2d, Util.DimensionType.Column);
+
+            return info;
+        }
+
+
+        /// <summary>
+        /// Get the item values for Wide Range IRT method.
+        /// </summary>
+        /// <param name="theta">The current theta value</param>
+        /// <param name="bin">The current bin assignment</param>
+        /// <returns>Double array of item values</returns>
+        private double[] WideRangeItemValues(double theta, int bin)
+        {
+            double[] ItemValues = new double[_NumTotalItems];
+            int[] ItemIndexes = new int[_NumTotalItems];
+            List<int> Items = new List<int>();
+            double Probability;
+            SortedList<int, double> Diffs = new SortedList<int, double>();
+            double MinDiff;
+            List<int> BinRange = new List<int>();
+
+            //method: #1=Maximum Information (MI)   #2=Stradaptive   #3=MI within +- noise   #4=Stradaptive/MI
+
+            //if (method %in% c(1,3) || (method==4 && ni.given>nStradaptive)) {
+            if ((_SelectionMethod == (int)SelectionMethodType.MaximumInformation || _SelectionMethod == (int)SelectionMethodType.MaximumInformationWithNoise || _SelectionMethod == (int)SelectionMethodType.MaximumInformationProgressiveRestricted)
+               || (_SelectionMethod == (int)SelectionMethodType.StradaptiveWithMaximumInformation && _ItemsAsked.Count > _MinNumStradaptive)) {
+
+                //bin<-locate(th,mean.theta.bin)             # find bin of this theta: closest average value
+                //        locate<-function(val,vec) { which(abs(vec-val)==min(abs(vec-val))) }
+                foreach (int i in _BinAverages.Keys) {
+                    Diffs[i] = Math.Abs(_BinAverages[i] - theta);
+                }
+                MinDiff = Diffs.Values.AsQueryable().Min();
+                BinRange.Add(Diffs.Keys[Diffs.IndexOfValue(MinDiff)]);
+
+                /*
+                bin<-expand(bin,1,nbin)                    # expand the bin range by 1
+                items<-which(BIN %in% bin)                 # find index locations of items within the bin range
+                while (sum(items.available[items])==0) {   # if no items available within the bin range
+                    bin<-expand(bin,1,nbin)                # expand the bin range by 1
+                    items<-which(BIN %in% bin)             # find index locations of items within the expanded bin range
+                }                                          # repeat (if no items available within the bin range)
+                 */
+                ItemIndexes = ItemsIndexesInBinRange(BinRange, true);
+
+                //if (method==3) th<-th+runif(1)*2*noiseML-noiseML
+                if (_SelectionMethod == (int)SelectionMethodType.MaximumInformationWithNoise) {
+                    theta = theta + Util.RandomNumber.NextDouble() * 2.0 * _NoiseRange - _NoiseRange;
+                }
+
+                //for (i in items) {
+                for (int i = 0; i < ItemIndexes.Length; i++) {
+                    //if (items.available[i]==TRUE) {
+                    if ((_ItemsAvailable[i] == 1) && (ItemIndexes[i] == 1)) {
+                        //P<-1/(1+exp(-D*A[i]*(th-B[i])))
+                        Probability = 1 / (1 + Math.Exp((-1) * _LogisticScaling * _DiscriminationValues[i] * (theta - _Difficulty[i])));
+                        //Q<-1-P
+                        //index[i]<-D^2*A[i]^2*P*Q
+                        ItemValues[i] = Math.Pow(_LogisticScaling, 2.0) * Math.Pow(_DiscriminationValues[i], 2.0) * Probability * (1.0 - Probability);
+                    }
+                }
+
+                if (_SelectionMethod == (int)SelectionMethodType.MaximumInformationProgressiveRestricted) {
+                    double MaxItemValue = ItemValues.AsQueryable().Max();
+                    double Weight = (double)(_ItemsAsked.Count + 1) / _MaxNumItems;
+
+                    for (int i = 0; i < ItemIndexes.Length; i++) {
+                        if ((_ItemsAvailable[i] == 1) && (ItemIndexes[i] == 1)) {
+                            ItemValues[i] = Util.RandomNumber.NextDouble() * MaxItemValue * (1 - Weight) + Weight * ItemValues[i];
+                        }
+                    }
+
+                    /*
+                    if (method==5) { #added for PR
+                        rc<-numeric(ni) #random component
+                        wt<-ni.given/maxNI #weight
+                        for (i in items) {
+                            if (items.available[i]==TRUE) {
+                                rc[i]<-get.rn()*max(index,na.rm=T) #uniform from (0,H) where H=max information value
+                                index[i]<-rc[i]*(1-wt)+wt*index[i] #PR weighting
+                            }
+                        }
+                    }
+                    */
+                }
+            }
+
+            //} else if (method %in% c(2,4)) {
+            else if ((_SelectionMethod == (int)SelectionMethodType.Stradaptive) || (_SelectionMethod == (int)SelectionMethodType.StradaptiveWithMaximumInformation)) {
+                BinRange.Add(bin);
+
+                //if (is.na(bin)) {
+                if (BinRange.Count() == 0) {
+                    //items<-1:ni
+                    for (int i = 0; i < ItemIndexes.Count(); i++) {
+                        ItemIndexes[i] = 1;
+                    }
+                }
+                //} else {
+                else {
+                    /*
+                    items<-which(BIN %in% bin)
+                    while (sum(items.available[items])==0) {
+                        bin<-expand(bin,1,nbin)
+                        items<-which(BIN %in% bin)
+                    }
+                    */
+                    ItemIndexes = ItemsIndexesInBinRange(BinRange, false);
+                }
+                /*
+                for (i in items) {
+                    if (items.available[i]==TRUE) index[i]<-runif(1)
+                }
+                */
+                for (int i = 0; i < ItemValues.Count(); i++) {
+                    if ((_ItemsAvailable[i] == 1) && (ItemIndexes[i] == 1)) {
+                        ItemValues[i] = Util.RandomNumber.NextDouble();
+                    }
+                }
+            }
+
+            //return(index);
+            return ItemValues;
+        }
+
+
+        /// <summary>
+        /// Calculates the standard error for the Wide Range IRT method.
+        /// </summary>
+        /// <returns>nothing</returns>
+        private void CalcStandardError()
+        {
+            int ItemIndex;
+            double Probability;
+            double info = 0.0;
+            for (int i = 0; i < _ItemsAsked.Count; i++) {
+                ItemIndex = (int)_ItemsAsked[i];
+                Probability = 1 / (1 + Math.Exp((-1) * _LogisticScaling * _DiscriminationValues[ItemIndex] * (_Theta - _Difficulty[ItemIndex])));
+                info = info + Math.Pow(_LogisticScaling, 2) * Math.Pow(_DiscriminationValues[ItemIndex], 2) * Probability * (1 - Probability);
+            }
+            _StdError = 1 / Math.Sqrt(info);
+
+            /*
+              calcSE<-function(examinee,ngiven,th) {
+                info<-0;
+                for (i in 1:ngiven) {
+                    item<-items.used[examinee,i]
+                    P<-1/(1+exp(-D*A[item]*(th-B[item])))
+                    Q<-1-P
+                    info<-info+D^2*A[item]^2*P*Q
+                }
+                SEM<-1/sqrt(info)
+                return(SEM)
+              }
+             */
+        }
+
+
+        /// <summary>
+        /// Calculates the maximum likelihood estimate for the Wide Range IRT method.
+        /// </summary>
+        /// <returns>nothing</returns>
+        private void CalcMaximumLikelihoodEstimate()
+        {
+            double ThetaEst = _Theta;
+            int iteration = 0;
+            bool converged = false;
+            double info;
+            double change;
+            double SumScore;
+            double SumProbability;
+            double Probability;
+            int ItemIndex;;
+            int ResponseIndex;
+
+            do {
+                SumScore = 0.0;
+                SumProbability = 0.0;
+                info = 0.0;
+                for (int i = 0; i < _ItemsAsked.Count; i++) {
+                    ItemIndex = (int)_ItemsAsked[i];
+                    ResponseIndex = (int)_Responses[i];
+                    Probability = 1 / ( 1 + Math.Exp((-1) * _LogisticScaling * _DiscriminationValues[ItemIndex] * (ThetaEst - _Difficulty[ItemIndex])) );
+                    info = info + Math.Pow(_LogisticScaling, 2) * Math.Pow(_DiscriminationValues[ItemIndex], 2) * Probability * (1 - Probability);
+                    SumScore = SumScore + _DiscriminationValues[ItemIndex] * ResponseIndex;
+                    SumProbability = SumProbability + _DiscriminationValues[ItemIndex] * Probability;
+                }
+
+                change = (SumScore - SumProbability) / ((-1) * info);
+                if (Math.Abs(change) <= _Convergence) {
+                    converged = true;
+                }
+                if (Math.Abs(change) > 0.5) {
+                    change = (change >= 0) ? 0.5 : -0.5;
+                }
+                ThetaEst -= change;
+
+                iteration++;
+            } while ((iteration <= _MaxNumIterations) && (!converged));
+
+            _MaximumLikelihoodTheta = ThetaEst;
+            _MaximumLikelihoodError = 1 / Math.Sqrt(info);
+            /*
+                F means FALSE (a logical/Boolean literal)
+                P means Probability of a correct response
+                Q means Probability of an incorrect response
+                U means a realized (observed) response
+
+              calcMLE<-function(examinee,ngiven) {
+	            post.theta<-theta.current
+	            nIter<-0
+	            converged<-F
+	            while (nIter<=maxIter && !converged) {
+		            pre.theta<-post.theta
+		            sum.score<-0
+		            sum.p<-0
+		            info<-0
+		            for (i in 1:ngiven) {
+			            item<-items.used[examinee,i]
+			            P<-1/(1+exp(-D*A[item]*(pre.theta-B[item])))
+			            Q<-1-P
+			            info<-info+D^2*A[item]^2*P*Q
+			            U<-resp[examinee,item]
+			            sum.score<-sum.score+A[item]*U
+			            sum.p<-sum.p+A[item]*P
+		            }
+		            change<-(sum.score-sum.p)/-info
+		            if (abs(change)<=crit) converged=T
+		            if (abs(change)>0.5) change<-sign(change)*0.5
+		            post.theta<-pre.theta-change
+		            nIter<-nIter+1
+	            }
+	            return(list(theta=post.theta,SE=1/sqrt(info)))
+              }
+
+             */
+
+        }
+
+
+
+        private int[] ItemsIndexesInBinRange(List<int> binRange, bool expandRangeFirst)
+        {
+            int BinRangeStart;
+            int BinRangeEnd;
+            bool NoneFound = true;
+            int[] BinItemsAvailable = new int[_Bin.Count()];
+            int ItemNum;
+            int BinNum;
+            int iteration = 0;
+
+            /*
+            bin<-expand(bin,1,nbin)                    # expand the bin range by 1
+            items<-which(BIN %in% bin)                 # find index locations of items within the bin range
+            while (sum(items.available[items])==0) {   # if no items available within the bin range
+                bin<-expand(bin,1,nbin)                # expand the bin range by 1
+                items<-which(BIN %in% bin)             # find index locations of items within the expanded bin range
+            }                                          # repeat (if no items available within the bin range)
+             */
+
+            do {
+                iteration++;
+                if ((expandRangeFirst && (iteration == 1)) || (iteration > 1)) {
+                    BinRangeStart = (_BinAverages.IndexOfKey(binRange[0]) == 0) ? 0 : _BinAverages.IndexOfKey(binRange[0]) - 1;
+                    BinRangeEnd = (_BinAverages.IndexOfKey(binRange[binRange.Count - 1]) == _BinAverages.Count - 1) ? _BinAverages.Count - 1 : _BinAverages.IndexOfKey(binRange[binRange.Count - 1]) + 1;
+                    if (!(binRange.Contains(_BinAverages.Keys[BinRangeStart]))) {
+                        binRange.Add(_BinAverages.Keys[BinRangeStart]);
+                    }
+                    if (!(binRange.Contains(_BinAverages.Keys[BinRangeEnd]))) {
+                        binRange.Add(_BinAverages.Keys[BinRangeEnd]);
+                    }
+                }
+                binRange.Sort();
+
+                ItemNum = 0;
+                while (ItemNum < _Bin.Count()) {
+                    BinNum = 0;
+                    while (BinNum < binRange.Count()) {
+                        if (_Bin[ItemNum] == binRange[BinNum] && _ItemsAvailable[ItemNum] == 1) {
+                            BinItemsAvailable[ItemNum] = 1;
+                            NoneFound = false;
+                        }
+                        BinNum++;
+                    }
+                    ItemNum++;
+                }
+            } while (NoneFound && !((_BinAverages.IndexOfKey(binRange[0]) == 0) && (_BinAverages.IndexOfKey(binRange[binRange.Count - 1]) == _BinAverages.Count - 1)));
+
+            return BinItemsAvailable;
+        }
+
+        #endregion
+
+    }
+}