cat_engine 0.1.0

data/vendor/cat_engine/IEngine.cs

@@ -0,0 +1,65 @@
+
+namespace CORE.Engines
+{
+	using System;
+	using System.Xml;
+
+	public interface IEngine
+	{
+
+		XmlDocument getCurrentItem();
+		XmlDocument getPreviousItem();
+		XmlDocument getNextItem();
+		XmlDocument getForm();
+
+
+		void updateNode(XmlNode node);
+		bool loadItems(XmlDocument doc, XmlDocument FormParams, bool WithHeader);
+
+		void decrementPosition();
+		void incrementPosition();
+		void rollbackPosition();
+
+		bool finished
+		{
+			get;
+		}
+		bool IsCompleted
+		{
+			get;
+		}
+		bool IsResume
+		{
+			get;
+		}
+		int currentPosition
+		{
+			get;
+			set;
+		}
+		int previousPosition
+		{
+			get;
+			set;
+		}
+
+		int TotalItems
+		{
+			get;
+		}
+
+		string message
+		{
+			get;
+			set;
+		}
+
+		string paramPROC
+		{
+			get;
+		}
+
+
+	}
+
+}

data/vendor/cat_engine/ShellWrapper.cs

@@ -0,0 +1,44 @@
+namespace CORE.Engines
+{
+  using System;
+  using System.Xml;
+
+  public class ShellWrapper
+  {
+    static void Main(string[] args)
+    {
+      // get form id from command line args
+      string formID = args[0];
+
+      XmlDocument doc = new XmlDocument();
+      doc.Load("forms/" + formID + ".xml");
+
+      XmlDocument formParams = new XmlDocument();
+      formParams.Load("parameters/" + formID + ".xml");
+
+      CATEngine3 e = new CATEngine3();
+      e.loadItems(doc, formParams, true);
+      
+      // get answers from command line args if they exist
+      string responseID = "";
+      for(int i = 1; i < args.Length; i++) {
+        responseID = args[i];
+        XmlDocument nextItem = e.getNextItem();
+        XmlElement item = (XmlElement)nextItem.GetElementsByTagName("Item")[0];
+        item.SetAttribute("ItemResponseOID", responseID);
+        // item.Attributes["Response"].Value = responseID;
+        // item.Attributes["ResponseTime"].Value = "10";
+        e.updateNode(item);
+      }
+      
+      if(e.finished) {
+        double theta = e.ThetaHistory[e.ThetaHistory.Length - 1];
+        double stdError = e.StdErrorHistory[e.StdErrorHistory.Length - 1];
+        Console.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Results Theta=\"" + theta + "\" StdError=\"" + stdError + "\" />");
+
+      } else {
+        e.getCurrentItem().Save(Console.Out);
+      }
+    }
+  }
+}

data/vendor/cat_engine/Util.cs

@@ -0,0 +1,825 @@
+namespace CORE.Engines
+{
+	using System;
+	using System.Collections;
+    using System.Collections.Generic;
+	using System.IO;
+    using System.Linq;
+	using System.Text;
+
+
+	/// <summary>
+	/// A set of general utilities.
+	/// </summary>
+	public class Util
+	{
+		/// <summary>
+		/// Enumerator for the dimension type. These are dimension names for a matrix.
+		/// </summary>
+		public enum DimensionType
+		{
+			/// <summary>Dimension 0</summary>
+			Row,
+			/// <summary>Dimension 1</summary>
+			Column,
+			/// <summary>Dimension 2</summary>
+			Depth
+		};
+
+		/// <summary>
+		/// Reads a two-dimensional table of numbers from a text file.
+		/// </summary>
+		/// <param name="SourceFilename">The source filename.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <returns>A two-dimensional array of numbers (double data type).</returns>
+		/// <remarks>Assumes carriage return/line feed at the end of every row. 
+		/// Assumes no delimiter at the end of every row.</remarks>
+		public static double[][] Read2DNumericTable(string SourceFilename, string Delimiter)
+		{
+			double[][] data;
+			FileInfo SourceFile;
+			StreamReader Reader;
+			ArrayList ar1d;
+			ArrayList ar2d;
+			int start;
+			int end;
+
+			ar2d = new ArrayList();
+			SourceFile = new FileInfo(SourceFilename);
+			Reader = SourceFile.OpenText();
+			string TextLine;
+			do {
+				TextLine = Reader.ReadLine();
+				if ( TextLine != null ) {
+					TextLine = TextLine.Trim();
+					ar1d = new ArrayList();
+					start = 0;
+					end = 0;
+					while ( end != -1 ) {
+						end = TextLine.IndexOf(Delimiter, start);
+						if ( start != end ) {
+							//if start == end then delimiter is the next character so skip it
+							if ( end == -1 && TextLine.Length != 0 ) {
+								//Last number in the line with no delimiter at the end
+								ar1d.Add(Convert.ToDouble(TextLine.Substring(start).Trim()));
+							}
+							else {
+								ar1d.Add(Convert.ToDouble(TextLine.Substring(start, (end - start)).Trim()));
+							}
+						}
+						start = end + 1;
+					}
+					ar2d.Add(ar1d.ToArray(typeof(double)));
+				}
+			} while ( TextLine != null );
+
+			data = (double[][])ar2d.ToArray(typeof(double[]));
+			Reader.Close();
+
+			return data;
+		}
+
+        /// <summary>
+        /// Reads a list of numbers from a text file
+        /// </summary>
+        /// <param name="SourceFilename">The source filename.</param>
+        /// <returns>An array of numbers (double data type)</returns>
+        /// <remarks>Assumes carriage return/line feed at the end of every line, with one number per line.
+        /// Lines that cannot be evaluated to valid numbers are skipped.</remarks>
+        public static double[] ReadNumericList(string SourceFilename)
+        {
+            double result;
+
+            List<double> liList = new List<double>();
+            FileInfo SourceFile = new FileInfo(SourceFilename);
+            StreamReader Reader = SourceFile.OpenText();
+            string TextLine;
+
+            do {
+                TextLine = Reader.ReadLine();
+                if (TextLine != null) {
+                    TextLine = TextLine.Trim();
+                    if (double.TryParse(TextLine, out result)) {
+                        liList.Add(result);
+                    }
+                }
+            } while (TextLine != null);
+
+            Reader.Close();
+
+            return liList.ToArray();
+        }
+
+
+		#region WriteNumericArrayToFile (overloaded)
+
+		/// <summary>
+		/// Writes a two-dimensional table of numbers to a text file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">If set to <c>true</c> append to the end of the file.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <param name="data">The data to be written.</param>
+		/// <remarks>Data is a 2D jagged array.</remarks>
+		public static void WriteNumericArrayToFile(string TargetFilename, bool AppendToFile, string Delimiter, double[][] data)
+		{
+			StreamWriter Writer;
+			int i;
+			int j;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			StringBuilder TextLine;
+			for ( i = 0; i < data.Length; i++ ) {
+				TextLine = new StringBuilder();
+				for ( j = 0; j < data[i].Length; j++ ) {
+					TextLine.Append(data[i][j]);
+					//no delimiter at the end
+					if ( j != data[i].Length - 1 ) {
+						TextLine.Append(Delimiter);
+					}
+				}
+				Writer.WriteLine(TextLine.ToString());
+			}
+			Writer.Close();
+		}
+
+		/// <summary>
+		/// Writes a two-dimensional table of numbers to a text file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">If set to <c>true</c> append to the end of the file.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <param name="data">The data to be written.</param>
+		/// <remarks>Data is a 2D rectangular array.</remarks>
+		public static void WriteNumericArrayToFile(string TargetFilename, bool AppendToFile, string Delimiter, double[,] data)
+		{
+			StreamWriter Writer;
+			int i;
+			int j;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			StringBuilder TextLine;
+			for ( i = 0; i < data.GetLength(0); i++ ) {
+				TextLine = new StringBuilder();
+				for ( j = 0; j < data.GetLength(1); j++ ) {
+					TextLine.Append(data[i, j]);
+					//no delimiter at the end
+					if ( j != data.GetLength(1) - 1 ) {
+						TextLine.Append(Delimiter);
+					}
+				}
+				Writer.WriteLine(TextLine.ToString());
+			}
+			Writer.Close();
+		}
+
+		/// <summary>
+		/// Writes an array of numbers to a text file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">If set to <c>true</c> append to the end of the file.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <param name="data">The data to be written.</param>
+		/// <remarks>Data is a 1D array.</remarks>
+		public static void WriteNumericArrayToFile(string TargetFilename, bool AppendToFile, string Delimiter, double[] data)
+		{
+			StreamWriter Writer;
+			int i;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			StringBuilder TextLine;
+			TextLine = new StringBuilder();
+			for ( i = 0; i < data.Length; i++ ) {
+				TextLine.Append(data[i]);
+				//no delimiter at the end
+				if ( i != data.Length - 1 ) {
+					TextLine.Append(Delimiter);
+				}
+			}
+			Writer.WriteLine(TextLine.ToString());
+			Writer.Close();
+		}
+
+		/// <summary>
+		/// Writes a two-dimensional table of numbers to a text file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">If set to <c>true</c> append to the end of the file.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <param name="data">The data to be written.</param>
+		/// <remarks>Data is a 2D jagged array.</remarks>
+		public static void WriteNumericArrayToFile(string TargetFilename, bool AppendToFile, string Delimiter, int[][] data)
+		{
+			StreamWriter Writer;
+			int i;
+			int j;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			StringBuilder TextLine;
+			for ( i = 0; i < data.Length; i++ ) {
+				TextLine = new StringBuilder();
+				for ( j = 0; j < data[i].Length; j++ ) {
+					TextLine.Append(data[i][j]);
+					//no delimiter at the end
+					if ( j != data[i].Length - 1 ) {
+						TextLine.Append(Delimiter);
+					}
+				}
+				Writer.WriteLine(TextLine.ToString());
+			}
+			Writer.Close();
+		}
+
+		/// <summary>
+		/// Writes a two-dimensional table of numbers to a text file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">If set to <c>true</c> append to the end of the file.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <param name="data">The data to be written.</param>
+		/// <remarks>Data is a 2D rectangular array.</remarks>
+		public static void WriteNumericArrayToFile(string TargetFilename, bool AppendToFile, string Delimiter, int[,] data)
+		{
+			StreamWriter Writer;
+			int i;
+			int j;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			StringBuilder TextLine;
+			for ( i = 0; i < data.GetLength(0); i++ ) {
+				TextLine = new StringBuilder();
+				for ( j = 0; j < data.GetLength(1); j++ ) {
+					TextLine.Append(data[i, j]);
+					//no delimiter at the end
+					if ( j != data.GetLength(1) - 1 ) {
+						TextLine.Append(Delimiter);
+					}
+				}
+				Writer.WriteLine(TextLine.ToString());
+			}
+			Writer.Close();
+		}
+
+		/// <summary>
+		/// Writes an array of numbers to a text file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">If set to <c>true</c> append to the end of the file.</param>
+		/// <param name="Delimiter">The delimiter separating the numeric values.</param>
+		/// <param name="data">The data to be written.</param>
+		/// <remarks>Data is a 1D array.</remarks>
+		public static void WriteNumericArrayToFile(string TargetFilename, bool AppendToFile, string Delimiter, int[] data)
+		{
+			StreamWriter Writer;
+			int i;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			StringBuilder TextLine;
+			TextLine = new StringBuilder();
+			for ( i = 0; i < data.Length; i++ ) {
+				TextLine.Append(data[i]);
+				//no delimiter at the end
+				if ( i != data.Length - 1 ) {
+					TextLine.Append(Delimiter);
+				}
+			}
+			Writer.WriteLine(TextLine.ToString());
+			Writer.Close();
+		}
+
+		#endregion
+
+		/// <summary>
+		/// Writes a text string to a file.
+		/// </summary>
+		/// <param name="TargetFilename">The target filename.</param>
+		/// <param name="AppendToFile">if set to <c>true</c> append to the end of the file.</param>
+		/// <param name="data">The text to write to the file.</param>
+		public static void WriteStringToFile(string TargetFilename, bool AppendToFile, string data)
+		{
+			StreamWriter Writer;
+
+			Writer = new StreamWriter(TargetFilename, AppendToFile);
+			Writer.WriteLine(data);
+			Writer.Close();
+		}
+
+		/// <summary>
+		/// Sets the normal distribution.
+		/// </summary>
+		/// <param name="DataArray">The input data array.</param>
+		/// <param name="Mean">The mean around which to set the distribution.</param>
+		/// <param name="StdDev">The standard deviation to use for the distribution.</param>
+		/// <returns>
+		/// An array with the normal distribution points around the given mean and standard deviation for the data array given.
+		/// If the mean is null then 0.0 is used. If the standard deviation is null or zero then 1.0 is used.
+		/// </returns>
+		public static double[] SetNormalDistribution(double[] DataArray, double Mean, double StdDev)
+		{
+			if ( DataArray == null ) {
+				return null;
+			}
+			if ( Mean.Equals(null) ) {
+				Mean = 0.0;
+			}
+			if ( StdDev.Equals(null) ) {
+				StdDev = 1.0;
+			}
+			else if ( StdDev <= 0.0 ) {
+				StdDev = 1.0;
+			}
+			ArrayList ar1d = new ArrayList();
+			double tmp;
+			for ( int i = 0; i < DataArray.Length; i++ ) {
+				tmp = (DataArray[i] - Mean) / StdDev;
+				ar1d.Add(1 / Math.Sqrt(2 * Math.PI) * Math.Exp(-0.5 * tmp * tmp));
+			}
+			return (double[])ar1d.ToArray(typeof(double));
+		}
+
+		#region MatrixMultiply (overloaded)
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 1D.</param>
+		/// <param name="b">The second matrix, 2D.</param>
+		/// <returns>The product of two matricies. Result will be the same size as the 2D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row) * b(row,col) with dimensions of b. "row" must be equal for both a and b,
+		/// or null value is returned.
+		/// </remarks>
+		public static double[,] MatrixMultiply(double[] a, double[,] b)
+		{
+			if ( a.Length != b.GetLength(0) ) {
+				return null;
+			}
+			double[,] Product = new double[b.GetLength(0), b.GetLength(1)];
+
+			for ( int row = 0; row < b.GetLength(0); row++ ) {
+				for ( int col = 0; col < b.GetLength(1); col++ ) {
+					Product[row, col] = b[row, col] * a[row];
+				}
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 1D.</param>
+		/// <param name="b">The second matrix, 2D.</param>
+		/// <returns>The product of two matricies. Result will be the same size as the 2D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row) * b(row,col) with dimensions of b. "row" must be equal for both a and b,
+		/// or null value is returned.
+		/// </remarks>
+		public static double[,] MatrixMultiply(int[] a, double[,] b)
+		{
+			if ( a.Length != b.GetLength(0) ) {
+				return null;
+			}
+			double[,] Product = new double[b.GetLength(0), b.GetLength(1)];
+
+			for ( int row = 0; row < b.GetLength(0); row++ ) {
+				for ( int col = 0; col < b.GetLength(1); col++ ) {
+					Product[row, col] = b[row, col] * a[row];
+				}
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 1D.</param>
+		/// <param name="b">The second matrix, 2D.</param>
+		/// <returns>The product of two matricies. Result will be the same size as the 2D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row) * b(row,col) with dimensions of b. "row" must be equal for both a and b,
+		/// or null value is returned.
+		/// </remarks>
+		public static double[,] MatrixMultiply(double[] a, int[,] b)
+		{
+			if ( a.Length != b.GetLength(0) ) {
+				return null;
+			}
+			double[,] Product = new double[b.GetLength(0), b.GetLength(1)];
+
+			for ( int row = 0; row < b.GetLength(0); row++ ) {
+				for ( int col = 0; col < b.GetLength(1); col++ ) {
+					Product[row, col] = b[row, col] * a[row];
+				}
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 2D.</param>
+		/// <param name="b">The second matrix, 1D.</param>
+		/// <returns>The product of two matricies. Result will be the same size as the 2D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row,col) * b(row) with dimensions of a. "row" must be equal for both a and b,
+		/// or null value is returned.
+		/// </remarks>
+		public static double[,] MatrixMultiply(double[,] a, double[] b)
+		{
+			if ( b.Length != a.GetLength(0) ) {
+				return null;
+			}
+			double[,] Product = new double[a.GetLength(0), a.GetLength(1)];
+
+			for ( int row = 0; row < a.GetLength(0); row++ ) {
+				for ( int col = 0; col < a.GetLength(1); col++ ) {
+					Product[row, col] = a[row, col] * b[row];
+				}
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 2D.</param>
+		/// <param name="b">The second matrix, 1D.</param>
+		/// <returns>The product of two matricies. Result will be the same size as the 2D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row,col) * b(row) with dimensions of a. "row" must be equal for both a and b,
+		/// or null value is returned.
+		/// </remarks>
+		public static double[,] MatrixMultiply(int[,] a, double[] b)
+		{
+			if ( b.Length != a.GetLength(0) ) {
+				return null;
+			}
+			double[,] Product = new double[a.GetLength(0), a.GetLength(1)];
+
+			for ( int row = 0; row < a.GetLength(0); row++ ) {
+				for ( int col = 0; col < a.GetLength(1); col++ ) {
+					Product[row, col] = a[row, col] * b[row];
+				}
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 2D.</param>
+		/// <param name="b">The second matrix, 1D.</param>
+		/// <returns>The product of two matricies. Result will be the same size as the 2D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row,col) * b(row) with dimensions of a. "row" must be equal for both a and b,
+		/// or null value is returned.
+		/// </remarks>
+		public static double[,] MatrixMultiply(double[,] a, int[] b)
+		{
+			if ( b.Length != a.GetLength(0) ) {
+				return null;
+			}
+			double[,] Product = new double[a.GetLength(0), a.GetLength(1)];
+
+			for ( int row = 0; row < a.GetLength(0); row++ ) {
+				for ( int col = 0; col < a.GetLength(1); col++ ) {
+					Product[row, col] = a[row, col] * b[row];
+				}
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 1D.</param>
+		/// <param name="b">The second matrix, 1D.</param>
+		/// <returns>The product of two matricies. Result will be a 1D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row) * b(row) with dimensions of a. a and b must be the same size 
+		/// or null is returned.</remarks>
+		public static double[] MatrixMultiply(double[] a, double[] b)
+		{
+			if ( a.Length != b.Length ) {
+				return null;
+			}
+			double[] Product = new double[a.Length];
+
+			for ( int row = 0; row < a.Length; row++ ) {
+				Product[row] = a[row] * b[row];
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 1D.</param>
+		/// <param name="b">The second matrix, 1D.</param>
+		/// <returns>The product of two matricies. Result will be a 1D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row) * b(row) with dimensions of a. a and b must be the same size 
+		/// or null is returned.</remarks>
+		public static double[] MatrixMultiply(int[] a, double[] b)
+		{
+			if ( a.Length != b.Length ) {
+				return null;
+			}
+			double[] Product = new double[a.Length];
+
+			for ( int row = 0; row < a.Length; row++ ) {
+				Product[row] = a[row] * b[row];
+			}
+			return Product;
+		}
+
+		/// <summary>
+		/// Multiplies two matricies, item by item.
+		/// </summary>
+		/// <param name="a">The first matrix, 1D.</param>
+		/// <param name="b">The second matrix, 1D.</param>
+		/// <returns>The product of two matricies. Result will be a 1D matrix.</returns>
+		/// <remarks>
+		/// Each product is a(row) * b(row) with dimensions of a. a and b must be the same size 
+		/// or null is returned.</remarks>
+		public static double[] MatrixMultiply(double[] a, int[] b)
+		{
+			if ( a.Length != b.Length ) {
+				return null;
+			}
+			double[] Product = new double[a.Length];
+
+			for ( int row = 0; row < a.Length; row++ ) {
+				Product[row] = a[row] * b[row];
+			}
+			return Product;
+		}
+
+		#endregion
+
+		/// <summary>
+		/// Reduces a 2D matrix to 1D by summing each column or row.
+		/// </summary>
+		/// <param name="a">The matrix.</param>
+		/// <param name="ByDim">Dimension to sum by.</param>
+		/// <returns>1D matrix with summed values, having same length as the dimension to sum by.</returns>
+		public static double[] MatrixReduceBySum(double[,] a, DimensionType ByDim)
+		{
+			double[] sum;
+			int row;
+			int col;
+			if ( ByDim == DimensionType.Row ) {
+				sum = new double[a.GetLength(0)];
+				for ( row = 0; row < a.GetLength(0); row++ ) {
+					for ( col = 0; col < a.GetLength(1); col++ ) {
+						sum[row] = sum[row] + a[row, col];
+					}
+				}
+			}
+			else {
+				sum = new double[a.GetLength(1)];
+				for ( col = 0; col < a.GetLength(1); col++ ) {
+					for ( row = 0; row < a.GetLength(0); row++ ) {
+						sum[col] = sum[col] + a[row, col];
+					}
+				}
+			}
+			return sum;
+		}
+
+		#region ArraySum (overloaded)
+
+		/// <summary>
+		/// Sums all elements of a 1D array.
+		/// </summary>
+		/// <param name="a">The array to sum.</param>
+		/// <returns>The sum of all elements in the array.</returns>
+		public static double ArraySum(double[] a)
+		{
+			double info = 0;
+			for ( int i = 0; i < a.Length; i++ ) {
+				info = info + a[i];
+			}
+			return info;
+		}
+
+		/// <summary>
+		/// Sums all elements of a 1D array.
+		/// </summary>
+		/// <param name="a">The array to sum.</param>
+		/// <returns>The sum of all elements in the array.</returns>
+		public static double ArraySum(int[] a)
+		{
+			int info = 0;
+			for ( int i = 0; i < a.Length; i++ ) {
+				info = info + a[i];
+			}
+			return (double)info;
+		}
+
+		#endregion
+
+		/// <summary>
+		/// Slices one dimension from a 3D matrix.
+		/// </summary>
+		/// <param name="a">The 3D matrix.</param>
+		/// <param name="ByDim">The dimension to slice.</param>
+		/// <param name="x">Index of the first dimension to hold constant.</param>
+		/// <param name="DimX">The first constant dimension.</param>
+		/// <param name="y">Index of the second dimension to hold constant.</param>
+		/// <param name="DimY">The second constant dimension.</param>
+		/// <returns>A one dimensional array from the 3D matrix.</returns>
+		public static double[] MatrixSlice1D(double[, ,] a, DimensionType ByDim, int x, DimensionType DimX, int y, DimensionType DimY)
+		{
+			int ArraySize = a.GetLength((int)ByDim);
+			double[] ar1d = new double[ArraySize];
+			switch ( ByDim ) {
+				case DimensionType.Row:
+					for ( int i = 0; i < ArraySize; i++ ) {
+						if ( DimX == DimensionType.Column ) {
+							ar1d[i] = a[i, x, y];
+						}
+						else {
+							ar1d[i] = a[i, y, x];
+						}
+					}
+					break;
+				case DimensionType.Column:
+					for ( int i = 0; i < ArraySize; i++ ) {
+						if ( DimX == DimensionType.Row ) {
+							ar1d[i] = a[x, i, y];
+						}
+						else {
+							ar1d[i] = a[y, i, x];
+						}
+					}
+					break;
+				case DimensionType.Depth:
+					for ( int i = 0; i < ArraySize; i++ ) {
+						if ( DimX == DimensionType.Row ) {
+							ar1d[i] = a[x, y, i];
+						}
+						else {
+							ar1d[i] = a[y, x, i];
+						}
+					}
+					break;
+			}
+			return ar1d;
+		}
+
+        /// <summary>
+        /// Calculate averages across categories. Mimics the "tapply" method in R. Assumes that <c>categories</c> and <c>items</c>
+        /// are in the proper order with respect to each other.
+        /// </summary>
+        /// <param name="categories"><c>List</c> of categories of items.</param>
+        /// <param name="items"><c>List</c> of items.</param>
+        /// <returns><c>SortedList</c> of categories with their averages.</returns>
+        public static SortedList<int, double> CategoryAverages (List<int> categories, List<double> items)
+        {
+            if (items.Count != categories.Count) {
+                throw new ApplicationException("CategoryAverages: item/category count mismatch. ");
+            }
+            
+            SortedList<int, List<double>> slCat = new SortedList<int, List<double>>();
+            
+            for (int i=0; i<items.Count; i++) {
+                if (!(slCat.ContainsKey(categories[i]))) {
+                    List<double> Items = new List<double>();
+                    Items.Add(items[i]);
+                    slCat.Add(categories[i], Items);
+                }
+                else {
+                    slCat[categories[i]].Add(items[i]);
+                }
+            }
+
+            SortedList<int,double> averages = new SortedList<int,double>();
+
+            foreach (int i in slCat.Keys) {
+                averages[i] = slCat[i].AsQueryable().Average();
+            }
+            
+            return averages;
+        }
+
+        /// <summary>
+        /// Utility for random number selection. This can use the C# random number generator 
+        /// or use an input list (used for QA to ensure the same random number sequence).
+        /// </summary>
+        public class RandomNumber
+        {
+            private static int _Index;
+            private static int _ListCount;
+            private static double[] _NumberList;
+            private static Random _RandomNumber;
+            private static bool _UseList;
+
+            /// <summary>
+            /// Private constructor
+            /// </summary>
+            private RandomNumber ()
+            {
+                Init();
+            }
+
+            public static void Init ()
+            {
+                _UseList = false;
+                _RandomNumber = new Random(unchecked((int)DateTime.Now.Ticks));
+            }
+
+            /// <summary>
+            /// Initialize the generator to use a predetermined list of random numbers.
+            /// </summary>
+            /// <param name="randomNumberList">The list of predetermined random numbers, type <c>double</c>,  
+            /// with values from zero to one.</param>
+            public static void Init (double[] randomNumberList) {
+
+                if (randomNumberList.Count() == 0) {
+                    throw new ApplicationException("QArandom error: input list is empty");
+                }
+
+                _UseList = true;
+                _NumberList = randomNumberList;
+                _ListCount = _NumberList.Count();
+                _Index = -1;
+            }
+
+            /// <summary>
+            /// Get the next random number.
+            /// </summary>
+            /// <returns>A <c>double</c> between zero and one.</returns>
+            public static double NextDouble()
+            {
+                if (_UseList) {
+                    if (_Index == _ListCount-1) {
+                        //If at the end of the list go back to the beginning
+                        _Index = 0;
+                    }
+                    else {
+                        _Index++;
+                    }
+                    return _NumberList[_Index];
+                }
+                else {
+                    if (_RandomNumber == null) {
+                        Init();
+                    }
+                    return _RandomNumber.NextDouble();
+                }
+            }
+
+            /// <summary>
+            /// Get the next random number and scale it to the integer <c>maxValue</c>.
+            /// </summary>
+            /// <param name="maxValue">The maximum <c>integer</c> value to return</param>
+            /// <returns>A random <c>integer</c> between zero and <c>maxValue</c>.</returns>
+            public static int Next(int maxValue)
+            {
+                if (_UseList) {
+                    if (_Index == _ListCount-1) {
+                        //If at the end of the list go back to the beginning
+                        _Index = 0;
+                    }
+                    else {
+                        _Index++;
+                    }
+                    return (int)Math.Round(_NumberList[_Index] * maxValue);
+                }
+                else {
+                    if (_RandomNumber == null) {
+                        Init();
+                    }
+                    return _RandomNumber.Next(maxValue);
+                }
+            }
+
+        }
+
+
+        /// <summary>
+        /// A comparer for a list of double-int key-value pairs. This is required to allow sorting of this type of list.
+        /// </summary>
+        public class KVPDoubleIntComparer : IComparer<KeyValuePair<double,int>>
+        {
+            public int Compare ( KeyValuePair<double, int> kvp1, KeyValuePair<double, int> kvp2 )
+            {
+                //Check for equalities: use the same method as the R programming language
+                if ((kvp1.Key == kvp2.Key) && (kvp1.Value != kvp2.Value)) {
+                    if (kvp1.Value > kvp2.Value) {
+                        return 1;
+                    }
+                    else {
+                        return -1;
+                    }
+                }
+                else {
+                    return (kvp1.Key.CompareTo(kvp2.Key));
+                }
+            }
+        }
+
+	}
+
+}