Reorder documentation tags to be consistent

--- src/LpSolveDotNet/LpSolve.cs
+++ src/LpSolveDotNet/LpSolve.cs
@@ -92,15 +92,15 @@
                 );
         }

-#endregion
-
-#region Fields
+        #endregion
+
+        #region Fields

         private IntPtr _lp;

-#endregion
-
-#region Create/destroy model
+        #endregion
+
+        #region Create/destroy model

         /// <summary>
         /// Constructor, to be called from <see cref="CreateFromLpRecStructurePointer"/> only.
@@ -126,13 +126,13 @@
         /// <summary>
         /// Creates and initialises a new <see cref="LpSolve"/> model.
         /// </summary>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/make_lp.htm">Full C API documentation.</seealso>
         /// <param name="rows">Initial number of rows. Can be <c>0</c> as new rows can be added via
         /// <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>.</param>
         /// <param name="columns">Initial number of columns. Can be <c>0</c> as new columns can be added via
         /// <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>.</param>
         /// <returns>A new <see cref="LpSolve"/> model with <paramref name="rows"/> rows and <paramref name="columns"/> columns.
         /// A <c>null</c> return value indicates an error. Specifically not enough memory available to setup an lprec structure.</returns>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/make_lp.htm">Full C API documentation.</seealso>
         public static LpSolve make_lp(int rows, int columns)
         {
             IntPtr lp = Interop.make_lp(rows, columns);
@@ -142,13 +142,13 @@
         /// <summary>
         /// Creates and initialises a new <see cref="LpSolve"/> model from a LP model file.
         /// </summary>
-        /// <remarks>The model in the file must be in <see href="http://lpsolve.sourceforge.net/5.5/lp-format.htm">lp-format</see>.</remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_LP.htm">Full C API documentation.</seealso>
         /// <param name="fileName">Filename to read the LP model from.</param>
         /// <param name="verbose">The verbose level. See also <see cref="set_verbose"/> and <see cref="get_verbose"/>.</param>
         /// <param name="lpName">Initial name of the model. May be <c>null</c> if the model has no name. See also <see cref="set_lp_name"/> and <see cref="get_lp_name"/>.</param>
         /// <returns>A new <see cref="LpSolve"/> model matching the one in the file.
         /// A <c>null</c> return value indicates an error. Specifically file could not be opened, has wrong structure or not enough memory is available.</returns>
+        /// <remarks>The model in the file must be in <see href="http://lpsolve.sourceforge.net/5.5/lp-format.htm">lp-format</see>.</remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_LP.htm">Full C API documentation.</seealso>
         public static LpSolve read_LP(string fileName, lpsolve_verbosity verbose, string lpName)
         {
             IntPtr lp = Interop.read_LP(fileName, verbose, lpName);
@@ -158,14 +158,14 @@
         /// <summary>
         /// Creates and initialises a new <see cref="LpSolve"/> model from an MPS model file.
         /// </summary>
-        /// <remarks>The model in the file must be in <see href="http://lpsolve.sourceforge.net/5.5/mps-format.htm">mps-format</see>.</remarks>
-        /// <para>This method is different from C API because <paramref name="verbose"/> is separate from <paramref name="options"/></para>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_mps.htm">Full C API documentation.</seealso>
         /// <param name="fileName">Filename to read the MPS model from.</param>
         /// <param name="verbose">Specifies the verbose level. See also <see cref="set_verbose"/> and <see cref="get_verbose"/>.</param>
         /// <param name="options">Specifies how to interprete the MPS layout. You can use multiple values.</param>
         /// <returns>A new <see cref="LpSolve"/> model matching the one in the file.
         /// A <c>null</c> return value indicates an error. Specifically file could not be opened, has wrong structure or not enough memory is available.</returns>
+        /// <remarks>The model in the file must be in <see href="http://lpsolve.sourceforge.net/5.5/mps-format.htm">mps-format</see>.</remarks>
+        /// <para>This method is different from C API because <paramref name="verbose"/> is separate from <paramref name="options"/></para>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_mps.htm">Full C API documentation.</seealso>
         public static LpSolve read_MPS(string fileName, lpsolve_verbosity verbose, lpsolve_mps_options options)
         {
             IntPtr lp = Interop.read_MPS(fileName, ((int)verbose)|((int)options));
@@ -175,9 +175,6 @@
         /// <summary>
         /// Creates and initialises a new <see cref="LpSolve"/> model via the eXternal Language Interface.
         /// </summary>
-        /// <remarks>The method constructs a new <see cref="LpSolve"/> model by reading model from <paramref name="modelName"/> via the specified XLI.
-        /// See <see href="http://lpsolve.sourceforge.net/5.5/XLI.htm">Extnernal Language Interfaces</see>for a complete description on XLIs.</remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_XLI.htm">Full C API documentation.</seealso>
         /// <param name="xliName">Filename of the XLI package.</param>
         /// <param name="modelName">Filename to read the model from.</param>
         /// <param name="dataName">Filename to read the data from. This may be optional. In that case, set the parameter to <c>null</c>.</param>
@@ -185,6 +182,9 @@
         /// <param name="verbose">The verbose level. See also <see cref="set_verbose"/> and <see cref="get_verbose"/>.</param>
         /// <returns>A new <see cref="LpSolve"/> model matching the one in the file.
         /// A <c>null</c> return value indicates an error.</returns>
+        /// <remarks>The method constructs a new <see cref="LpSolve"/> model by reading model from <paramref name="modelName"/> via the specified XLI.
+        /// See <see href="http://lpsolve.sourceforge.net/5.5/XLI.htm">Extnernal Language Interfaces</see>for a complete description on XLIs.</remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_XLI.htm">Full C API documentation.</seealso>
         public static LpSolve read_XLI(string xliName, string modelName, string dataName, string options, lpsolve_verbosity verbose)
         {
             IntPtr lp = Interop.read_XLI(xliName, modelName, dataName, options, verbose);
@@ -194,9 +194,9 @@
         /// <summary>
         /// Copies current model to a new one.
         /// </summary>
+        /// <returns>A new model with the same values as current one or <c>null</c> if an error occurs (not enough memory).</returns>
         /// <remarks>The new model is independent from the original one.</remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/copy_lp.htm">Full C API documentation.</seealso>
-        /// <returns>A new model with the same values as current one or <c>null</c> if an error occurs (not enough memory).</returns>
         public LpSolve copy_lp()
         {
             IntPtr lp = Interop.copy_lp(_lp);
@@ -246,31 +246,36 @@
             Dispose(false);
         }

-#endregion
-
-#region Build model
-
-#region Column
+        #endregion
+
+        #region Build model
+
+        #region Column

         /// <summary>
         /// Adds a column to the model.
         /// </summary>
+        /// <param name="column">An array with 1+<see cref="get_Nrows"/> elements that contains the values of the column.</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
         /// <remarks><para>The method adds a column to the model (at the end) and sets all values of the column at once.</para>
         /// <para>Note that element 0 of the array is the value of the objective function for that column. Column 1 is element 1, column 2 is element 2, ...</para>
         /// <para>It is almost always better to use <see cref="add_columnex"/> instead of <see cref="add_column"/>. <see cref="add_columnex"/> is always at least as performant as <see cref="add_column"/>.</para>
         /// <para>Note that if you have to add many columns, performance can be improved by a call to <see cref="resize_lp"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_column.htm">Full C API documentation.</seealso>
-        /// <param name="column">An array with 1+<see cref="get_Nrows"/> elements that contains the values of the column.</param>
+        public bool add_column(double[] column)
+        {
+            return Interop.add_column(_lp, column);
+        }
+
+        /// <summary>
+        /// Adds a column to the model.
+        /// </summary>
+        /// <param name="count">Number of elements in <paramref name="column"/> and <paramref name="rowno"/>.</param>
+        /// <param name="column">An array with <paramref name="count"/> elements that contains the values of the column.</param>
+        /// <param name="rowno">A zero-based array with <paramref name="count"/> elements that contains the row numbers of the column.
+        /// However this variable can also be <c>null</c>. In that case element i in the variable <paramref name="column"/> is row i.</param>
         /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
-        public bool add_column(double[] column)
-        {
-            return Interop.add_column(_lp, column);
-        }
-
-        /// <summary>
-        /// Adds a column to the model.
-        /// </summary>
         /// <remarks><para>The method adds a column to the model (at the end) and sets all values of the column at once.</para>
         /// <para>Note that when <paramref name="rowno"/> is <c>null</c>, element 0 of the array is the value of the objective function for that column. Column 1 is element 1, column 2 is element 2, ...</para>
         /// <para>This method has the possibility to specify only the non-zero elements. In that case <paramref name="rowno"/> specifies the row numbers
@@ -283,70 +288,71 @@
         /// <para>Note that if you have to add many columns, performance can be improved by a call to <see cref="resize_lp"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_column.htm">Full C API documentation.</seealso>
+        public bool add_columnex(int count, double[] column, int[] rowno)
+        {
+            return Interop.add_columnex(_lp, count, column, rowno);
+        }
+
+        /// <summary>
+        /// Adds a column to the model.
+        /// </summary>
+        /// <param name="col_string">A string with row elements that contains the values of the column. Each element must be separated by space(s).</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
+        /// <remarks>This should only be used in small or demo code since it is not performant and uses more memory.
+        /// Instead use <see cref="add_columnex"/> or <see cref="add_column"/>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_column.htm">Full C API documentation.</seealso>
+        public bool str_add_column(string col_string)
+        {
+            return Interop.str_add_column(_lp, col_string);
+        }
+
+        /// <summary>
+        /// Deletes a column from the model.
+        /// </summary>
+        /// <param name="column">The column to delete. Must be between <c>1</c> and the number of columns in the model.</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise. An error occurs if <paramref name="column"/>
+        /// is not between <c>1</c> and the number of columns in the model</returns>
+        /// <remarks>
+        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
+        /// <para>The column is effectively deleted from the model, so all columns after this column shift one left.</para>
+        /// <para>Note that column 0 (the right hand side (RHS)) cannot be deleted. There is always a RHS.</para>
+        /// <para>Note that you can also delete multiple columns by a call to <see cref="resize_lp"/>.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/del_column.htm">Full C API documentation.</seealso>
+        public bool del_column(int column)
+        {
+            return Interop.del_column(_lp, column);
+        }
+
+
+        /// <summary>
+        /// Sets a column in the model.
+        /// </summary>
+        /// <param name="col_no">The column number that must be changed.</param>
+        /// <param name="column">An array with 1+<see cref="get_Nrows"/> elements that contains the values of the column.</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// <para>The method changes the values of an existing column in the model at once.</para>
+        /// <para>Note that element 0 of the array is row 0 (objective function). element 1 is row 1, ...</para>
+        /// <para>It is almost always better to use <see cref="set_columnex"/> instead of <see cref="set_column"/>. <see cref="set_columnex"/> is always at least as performant as <see cref="set_column"/>.</para>
+        /// <para>It is more performant to call this method than call <see cref="set_mat"/>.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_column.htm">Full C API documentation.</seealso>
+        public bool set_column(int col_no, double[] column)
+        {
+            return Interop.set_column(_lp, col_no, column);
+        }
+
+        /// <summary>
+        /// Sets a column in the model.
+        /// </summary>
+        /// <param name="col_no">The column number that must be changed.</param>
         /// <param name="count">Number of elements in <paramref name="column"/> and <paramref name="rowno"/>.</param>
         /// <param name="column">An array with <paramref name="count"/> elements that contains the values of the column.</param>
         /// <param name="rowno">A zero-based array with <paramref name="count"/> elements that contains the row numbers of the column.
         /// However this variable can also be <c>null</c>. In that case element i in the variable <paramref name="column"/> is row i.</param>
         /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
-        public bool add_columnex(int count, double[] column, int[] rowno)
-        {
-            return Interop.add_columnex(_lp, count, column, rowno);
-        }
-
-        /// <summary>
-        /// Adds a column to the model.
-        /// </summary>
-        /// <remarks>This should only be used in small or demo code since it is not performant and uses more memory.
-        /// Instead use <see cref="add_columnex"/> or <see cref="add_column"/>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_column.htm">Full C API documentation.</seealso>
-        /// <param name="col_string">A string with row elements that contains the values of the column. Each element must be separated by space(s).</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
-        public bool str_add_column(string col_string)
-        {
-            return Interop.str_add_column(_lp, col_string);
-        }
-
-        /// <summary>
-        /// Deletes a column from the model.
-        /// </summary>
-        /// <remarks>
-        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
-        /// <para>The column is effectively deleted from the model, so all columns after this column shift one left.</para>
-        /// <para>Note that column 0 (the right hand side (RHS)) cannot be deleted. There is always a RHS.</para>
-        /// <para>Note that you can also delete multiple columns by a call to <see cref="resize_lp"/>.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/del_column.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column to delete. Must be between <c>1</c> and the number of columns in the model.</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise. An error occurs if <paramref name="column"/>
-        /// is not between <c>1</c> and the number of columns in the model</returns>
-        public bool del_column(int column)
-        {
-            return Interop.del_column(_lp, column);
-        }
-
-
-        /// <summary>
-        /// Sets a column in the model.
-        /// </summary>
-        /// <remarks>
-        /// <para>The method changes the values of an existing column in the model at once.</para>
-        /// <para>Note that element 0 of the array is row 0 (objective function). element 1 is row 1, ...</para>
-        /// <para>It is almost always better to use <see cref="set_columnex"/> instead of <see cref="set_column"/>. <see cref="set_columnex"/> is always at least as performant as <see cref="set_column"/>.</para>
-        /// <para>It is more performant to call this method than call <see cref="set_mat"/>.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_column.htm">Full C API documentation.</seealso>
-        /// <param name="col_no">The column number that must be changed.</param>
-        /// <param name="column">An array with 1+<see cref="get_Nrows"/> elements that contains the values of the column.</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
-        public bool set_column(int col_no, double[] column)
-        {
-            return Interop.set_column(_lp, col_no, column);
-        }
-
-        /// <summary>
-        /// Sets a column in the model.
-        /// </summary>
         /// <remarks>
         /// <para>The method changes the values of an existing column in the model at once.</para>
         /// <para>Note that when <paramref name="rowno"/> is <c>null</c>, element 0 of the array is row 0 (objective function). element 1 is row 1, ...</para>
@@ -360,12 +366,6 @@
         /// <para>Note that unspecified values are set to zero.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_column.htm">Full C API documentation.</seealso>
-        /// <param name="col_no">The column number that must be changed.</param>
-        /// <param name="count">Number of elements in <paramref name="column"/> and <paramref name="rowno"/>.</param>
-        /// <param name="column">An array with <paramref name="count"/> elements that contains the values of the column.</param>
-        /// <param name="rowno">A zero-based array with <paramref name="count"/> elements that contains the row numbers of the column.
-        /// However this variable can also be <c>null</c>. In that case element i in the variable <paramref name="column"/> is row i.</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
         public bool set_columnex(int col_no, int count, double[] column, int[] rowno)
         {
             return Interop.set_columnex(_lp, col_no, count, column, rowno);
@@ -374,14 +374,14 @@
         /// <summary>
         /// Gets all column elements from the model for the given <paramref name="col_nr"/>.
         /// </summary>
-        /// <remarks>
-        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
-        /// <para>Note that element 0 of the array is row 0 (objective function). element 1 is row 1, ...</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_column.htm">Full C API documentation.</seealso>
         /// <param name="col_nr">The column number of the matrix. Must be between 1 and number of columns in the model.</param>
         /// <param name="column">Array in which the values are returned. The array must be dimensioned with at least 1+<see cref="get_Nrows"/> elements.</param>
         /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
+        /// <para>Note that element 0 of the array is row 0 (objective function). element 1 is row 1, ...</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_column.htm">Full C API documentation.</seealso>
         public bool get_column(int col_nr, double[] column)
         {
             return Interop.get_column(_lp, col_nr, column);
@@ -390,17 +390,17 @@
         /// <summary>
         /// Gets the non-zero column elements from the model for the given <paramref name="col_nr"/>.
         /// </summary>
-        /// <remarks>
-        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
-        /// <para>Returned values in <paramref name="column"/> and <paramref name="nzrow"/> start from element 0.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_column.htm">Full C API documentation.</seealso>
         /// <param name="col_nr">The column number of the matrix. Must be between 1 and number of columns in the model.</param>
         /// <param name="column">Array in which the values are returned. The array must be dimensioned with at least the number of non-zero elements in the column.
         /// If that is unknown, then use 1+<see cref="get_Nrows"/>.</param>
         /// <param name="nzrow">Array in which the row numbers  are returned. The array must be dimensioned with at least the number of non-zero elements in the column.
         /// If that is unknown, then use 1+<see cref="get_Nrows"/>.</param>
         /// <returns>The number of non-zero elements returned in <paramref name="column"/> and <paramref name="nzrow"/>.</returns>
+        /// <remarks>
+        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
+        /// <para>Returned values in <paramref name="column"/> and <paramref name="nzrow"/> start from element 0.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_column.htm">Full C API documentation.</seealso>
         public int get_columnex(int col_nr, double[] column, int[] nzrow)
         {
             return Interop.get_columnex(_lp, col_nr, column, nzrow);
@@ -409,14 +409,14 @@
         /// <summary>
         /// Sets the name of a column in the model.
         /// </summary>
-        /// <remarks>
-        /// The column must already exist.
-        /// Column names are optional.
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_col_name.htm">Full C API documentation.</seealso>
         /// <param name="column">The column for which the name must be set. Must be between 1 and the number of columns in the lp.</param>
         /// <param name="new_name">The name for the column.</param>
         /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// The column must already exist.
+        /// Column names are optional.
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_col_name.htm">Full C API documentation.</seealso>
         public bool set_col_name(int column, string new_name)
         {
             return Interop.set_col_name(_lp, column, new_name);
@@ -425,6 +425,8 @@
         /// <summary>
         /// Gets the name of a column in the model.
         /// </summary>
+        /// <param name="column">The column for which the name must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns>The name of the specified column if it was specified, Cx with x the column number otherwise or <c>null</c> on error.</returns>
         /// <remarks>
         /// <para>Column names are optional.
         /// If no column name was specified, the method returns Cx with x the column number.
@@ -437,16 +439,16 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_col_name.htm">Full C API documentation.</seealso>
+        public string get_col_name(int column)
+        {
+            return Interop.get_col_name(_lp, column);
+        }
+
+        /// <summary>
+        /// Gets the name of a column in the model.
+        /// </summary>
         /// <param name="column">The column for which the name must be set. Must be between 1 and the number of columns in the lp.</param>
         /// <returns>The name of the specified column if it was specified, Cx with x the column number otherwise or <c>null</c> on error.</returns>
-        public string get_col_name(int column)
-        {
-            return Interop.get_col_name(_lp, column);
-        }
-
-        /// <summary>
-        /// Gets the name of a column in the model.
-        /// </summary>
         /// <remarks>
         /// <para>Column names are optional.
         /// If no column name was specified, the method returns Cx with x the column number.
@@ -459,8 +461,6 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_col_name.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column for which the name must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns>The name of the specified column if it was specified, Cx with x the column number otherwise or <c>null</c> on error.</returns>
         public string get_origcol_name(int column)
         {
             return Interop.get_origcol_name(_lp, column);
@@ -469,12 +469,12 @@
         /// <summary>
         /// Returns whether the variable is negative or not.
         /// </summary>
-        /// <remarks>
-        /// Negative means a lower and upper bound that are both negative. Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity).
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_negative.htm">Full C API documentation.</seealso>
         /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
         /// <returns><c>true</c> if variable is defined as negative, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// Negative means a lower and upper bound that are both negative. Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity).
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_negative.htm">Full C API documentation.</seealso>
         public bool is_negative(int column)
         {
             return Interop.is_negative(_lp, column);
@@ -483,6 +483,8 @@
         /// <summary>
         /// Returns whether the variable is of type Integer or not.
         /// </summary>
+        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns><c>true</c> if variable is defined as integer, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Default a variable is not integer. From the moment there is at least one integer variable in the model,
         /// the Branch and Bound algorithm is used to make these variables integer.
@@ -490,8 +492,6 @@
         /// See <see href="http://lpsolve.sourceforge.net/5.5/integer.htm">integer variables</see> for a description about integer variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_int.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns><c>true</c> if variable is defined as integer, <c>false</c> otherwise.</returns>
         public bool is_int(int column)
         {
             return Interop.is_int(_lp, column);
@@ -500,6 +500,9 @@
         /// <summary>
         /// Sets the type of the variable to type Integer or floating point.
         /// </summary>
+        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <param name="must_be_int"><c>true</c> if variable must be an integer, <c>false</c> otherwise.</param>
+        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Default a variable is not integer. The argument <paramref name="must_be_int"/> defines what the status of the variable becomes.
         /// From the moment there is at least one integer variable in the model,
@@ -508,9 +511,6 @@
         /// See <see href="http://lpsolve.sourceforge.net/5.5/integer.htm">integer variables</see> for a description about integer variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_int.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <param name="must_be_int"><c>true</c> if variable must be an integer, <c>false</c> otherwise.</param>
-        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         public bool set_int(int column, bool must_be_int)
         {
             return Interop.set_int(_lp, column, must_be_int);
@@ -519,6 +519,8 @@
         /// <summary>
         /// Returns whether the variable is of type Binary or not.
         /// </summary>
+        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns><c>true</c> if variable is defined as binary, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Default a variable is not binary. A binary variable is an integer variable with lower bound 0 and upper bound 1.
         /// From the moment there is at least one integer variable in the model,
@@ -527,8 +529,6 @@
         /// See <see href="http://lpsolve.sourceforge.net/5.5/integer.htm">integer variables</see> for a description about integer variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_binary.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns><c>true</c> if variable is defined as binary, <c>false</c> otherwise.</returns>
         public bool is_binary(int column)
         {
             return Interop.is_binary(_lp, column);
@@ -537,6 +537,9 @@
         /// <summary>
         /// Sets the type of the variable to type Binary or floating point.
         /// </summary>
+        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <param name="must_be_bin"><c>true</c> if variable must be a binary, <c>false</c> otherwise.</param>
+        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Default a variable is not binary. A binary variable is an integer variable with lower bound 0 and upper bound 1.
         /// This method also sets these bounds.
@@ -547,9 +550,6 @@
         /// See <see href="http://lpsolve.sourceforge.net/5.5/integer.htm">integer variables</see> for a description about integer variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_binary.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <param name="must_be_bin"><c>true</c> if variable must be a binary, <c>false</c> otherwise.</param>
-        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         public bool set_binary(int column, bool must_be_bin)
         {
             return Interop.set_binary(_lp, column, must_be_bin);
@@ -558,13 +558,13 @@
         /// <summary>
         /// Returns whether the variable is of type semi-continuous or not.
         /// </summary>
+        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns><c>true</c> if variable is defined as semi-continuous, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Default a variable is not semi-continuous.
         /// See <see href="http://lpsolve.sourceforge.net/5.5/semi-cont.htm">semi-continuous variables</see> for a description about semi-continuous variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_semicont.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns><c>true</c> if variable is defined as semi-continuous, <c>false</c> otherwise.</returns>
         public bool is_semicont(int column)
         {
             return Interop.is_semicont(_lp, column);
@@ -573,6 +573,9 @@
         /// <summary>
         /// Sets the type of the variable to type semi-continuous or not.
         /// </summary>
+        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <param name="must_be_sc"><c>true</c> if variable must be a semi-continuous, <c>false</c> otherwise.</param>
+        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// By default, a variable is not semi-continuous. The argument <paramref name="must_be_sc"/> defines what the status of the variable becomes.
         /// Note that a semi-continuous variable must also have a lower bound to have effect.
@@ -582,17 +585,18 @@
         /// See <see href="http://lpsolve.sourceforge.net/5.5/semi-cont.htm">semi-continuous variables</see> for a description about semi-continuous variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_semicont.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <param name="must_be_sc"><c>true</c> if variable must be a semi-continuous, <c>false</c> otherwise.</param>
+        public bool set_semicont(int column, bool must_be_sc)
+        {
+            return Interop.set_semicont(_lp, column, must_be_sc);
+        }
+
+        /// <summary>
+        /// Sets the lower and upper bound of a variable.
+        /// </summary>
+        /// <param name="column">The column number of the variable on which the bounds must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <param name="lower">The lower bound on the variable identified by <paramref name="column"/>.</param>
+        /// <param name="upper">The upper bound on the variable identified by <paramref name="column"/>.</param>
         /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
-        public bool set_semicont(int column, bool must_be_sc)
-        {
-            return Interop.set_semicont(_lp, column, must_be_sc);
-        }
-
-        /// <summary>
-        /// Sets the lower and upper bound of a variable.
-        /// </summary>
         /// <remarks>
         /// Setting a bound on a variable is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a bound doesn't increase the model size that means that the model stays smaller and will be solved faster.
@@ -601,26 +605,22 @@
         /// The default upper bound of a variable is infinity(well not quite.It is a very big number, the value of <see cref="get_infinite"/>).
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_bounds.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable on which the bounds must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <param name="lower">The lower bound on the variable identified by <paramref name="column"/>.</param>
-        /// <param name="upper">The upper bound on the variable identified by <paramref name="column"/>.</param>
+        public bool set_bounds(int column, double lower, double upper)
+        {
+            return Interop.set_bounds(_lp, column, lower, upper);
+        }
+
+        /// <summary>
+        /// Sets if the variable is free.
+        /// </summary>
+        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
         /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
-        public bool set_bounds(int column, double lower, double upper)
-        {
-            return Interop.set_bounds(_lp, column, lower, upper);
-        }
-
-        /// <summary>
-        /// Sets if the variable is free.
-        /// </summary>
         /// <remarks>
         /// Free means a lower bound of -infinity and an upper bound of +infinity.
         /// Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity).
         /// See <see href="http://lpsolve.sourceforge.net/5.5/free.htm">free variables</see> for a description about free variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_unbounded.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable that must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         public bool set_unbounded(int column)
         {
             return Interop.set_unbounded(_lp, column);
@@ -629,14 +629,14 @@
         /// <summary>
         /// Returns whether the variable is free or not.
         /// </summary>
+        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns><c>true</c> if variable is defined as free, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Free means a lower bound of -infinity and an upper bound of +infinity.
         /// Default a variable is not free because default it has a lower bound of 0 (and an upper bound of +infinity).
         /// See <see href="http://lpsolve.sourceforge.net/5.5/free.htm">free variables</see> for a description about free variables.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_unbounded.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable to check. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns><c>true</c> if variable is defined as free, <c>false</c> otherwise.</returns>
         public bool is_unbounded(int column)
         {
             return Interop.is_unbounded(_lp, column);
@@ -645,15 +645,15 @@
         /// <summary>
         /// Gets the upper bound of a variable.
         /// </summary>
+        /// <param name="column">The column number of the variable. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns>The upper bound on the specified variable. If no bound was set, it returns a very big number,
+        /// the value of <see cref="get_infinite"/>, the default upper bound</returns>
         /// <remarks>
         /// Setting a bound on a variable is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a bound doesn't increase the model size that means that the model stays smaller and will be solved faster.
         /// The default upper bound of a variable is infinity(well not quite.It is a very big number, the value of <see cref="get_infinite"/>).
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_upbo.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns>The upper bound on the specified variable. If no bound was set, it returns a very big number,
-        /// the value of <see cref="get_infinite"/>, the default upper bound</returns>
         public double get_upbo(int column)
         {
             return Interop.get_upbo(_lp, column);
@@ -662,15 +662,15 @@
         /// <summary>
         /// Sets the upper bound of a variable.
         /// </summary>
+        /// <param name="column">The column number of the variable on which the bound must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <param name="value">The upper bound on the variable identified by <paramref name="column"/>.</param>
+        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Setting a bound on a variable is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a bound doesn't increase the model size that means that the model stays smaller and will be solved faster.
         /// The default upper bound of a variable is infinity(well not quite.It is a very big number, the value of <see cref="get_infinite"/>).
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_upbo.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable on which the bound must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <param name="value">The upper bound on the variable identified by <paramref name="column"/>.</param>
-        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         public bool set_upbo(int column, double value)
         {
             return Interop.set_upbo(_lp, column, value);
@@ -679,6 +679,8 @@
         /// <summary>
         /// Gets the lower bound of a variable.
         /// </summary>
+        /// <param name="column">The column number of the variable. Must be between 1 and the number of columns in the lp.</param>
+        /// <returns>The lower bound on the specified variable. If no bound was set, it returns 0, the default lower bound.</returns>
         /// <remarks>
         /// Setting a bound on a variable is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a bound doesn't increase the model size that means that the model stays smaller and will be solved faster.
@@ -686,8 +688,6 @@
         /// So variables will never take negative values if no negative lower bound is set.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_lowbo.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable. Must be between 1 and the number of columns in the lp.</param>
-        /// <returns>The lower bound on the specified variable. If no bound was set, it returns 0, the default lower bound.</returns>
         public double get_lowbo(int column)
         {
             return Interop.get_lowbo(_lp, column);
@@ -696,6 +696,9 @@
         /// <summary>
         /// Sets the lower bound of a variable.
         /// </summary>
+        /// <param name="column">The column number of the variable on which the bound must be set. Must be between 1 and the number of columns in the lp.</param>
+        /// <param name="value">The lower bound on the variable identified by <paramref name="column"/>.</param>
+        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// Setting a bound on a variable is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a bound doesn't increase the model size that means that the model stays smaller and will be solved faster.
@@ -703,21 +706,22 @@
         /// So variables will never take negative values if no negative lower bound is set.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_lowbo.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable on which the bound must be set. Must be between 1 and the number of columns in the lp.</param>
-        /// <param name="value">The lower bound on the variable identified by <paramref name="column"/>.</param>
-        /// <returns><c>true</c> if variable is operation was successful, <c>false</c> otherwise.</returns>
         public bool set_lowbo(int column, double value)
         {
             return Interop.set_lowbo(_lp, column, value);
         }

-#endregion // Build model /  Column
-
-#region Constraint / Row
+        #endregion // Build model /  Column
+
+        #region Constraint / Row

         /// <summary>
         /// Adds a constraint to the model.
         /// </summary>
+        /// <param name="row">An array with 1+<see cref="get_Ncolumns"/> elements that contains the values of the row.</param>
+        /// <param name="constr_type">The type of the constraint.</param>
+        /// <param name="rh">The value of the right-hand side (RHS) fo the constraint (in)equation</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>This method adds a row to the model (at the end) and sets all values of the row at once.</para>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
@@ -728,19 +732,22 @@
         /// <para>Note that if you have to add many constraints, performance can be improved by a call to <see cref="resize_lp"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_constraint.htm">Full C API documentation.</seealso>
-        /// <param name="row">An array with 1+<see cref="get_Ncolumns"/> elements that contains the values of the row.</param>
+        public bool add_constraint(double[] row, lpsolve_constr_types constr_type, double rh)
+        {
+            return Interop.add_constraint(_lp, row, constr_type, rh);
+        }
+
+
+        /// <summary>
+        /// Adds a constraint to the model.
+        /// </summary>
+        /// <param name="count">Number of elements in <paramref name="row"/> and <paramref name="colno"/>.</param>
+        /// <param name="row">An array with <paramref name="count"/> elements (or 1+<see cref="get_Ncolumns"/> elements if <paramref name="row"/> is <c>null</c>) that contains the values of the row.</param>
+        /// <param name="colno">An array with <paramref name="count"/> elements that contains the column numbers of the row. However this variable can also be <c>null</c>.
+        /// In that case element <c>i</c> in the variable row is column <c>i</c> and values start at element 1.</param>
         /// <param name="constr_type">The type of the constraint.</param>
         /// <param name="rh">The value of the right-hand side (RHS) fo the constraint (in)equation</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
-        public bool add_constraint(double[] row, lpsolve_constr_types constr_type, double rh)
-        {
-            return Interop.add_constraint(_lp, row, constr_type, rh);
-        }
-
-
-        /// <summary>
-        /// Adds a constraint to the model.
-        /// </summary>
         /// <remarks>
         /// <para>This method adds a row to the model (at the end) and sets all values of the row at once.</para>
         /// <para>Note that when <paramref name="row"/> is <c>null</c>, element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
@@ -755,21 +762,18 @@
         /// <para>Note that if you have to add many constraints, performance can be improved by a call to <see cref="resize_lp"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_constraint.htm">Full C API documentation.</seealso>
-        /// <param name="count">Number of elements in <paramref name="row"/> and <paramref name="colno"/>.</param>
-        /// <param name="row">An array with <paramref name="count"/> elements (or 1+<see cref="get_Ncolumns"/> elements if <paramref name="row"/> is <c>null</c>) that contains the values of the row.</param>
-        /// <param name="colno">An array with <paramref name="count"/> elements that contains the column numbers of the row. However this variable can also be <c>null</c>.
-        /// In that case element <c>i</c> in the variable row is column <c>i</c> and values start at element 1.</param>
+        public bool add_constraintex(int count, double[] row, int[] colno, lpsolve_constr_types constr_type, double rh)
+        {
+            return Interop.add_constraintex(_lp, count, row, colno, constr_type, rh);
+        }
+
+        /// <summary>
+        /// Adds a constraint to the model.
+        /// </summary>
+        /// <param name="row_string">A string with column elements that contains the values of the row. Each element must be separated by space(s).</param>
         /// <param name="constr_type">The type of the constraint.</param>
         /// <param name="rh">The value of the right-hand side (RHS) fo the constraint (in)equation</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
-        public bool add_constraintex(int count, double[] row, int[] colno, lpsolve_constr_types constr_type, double rh)
-        {
-            return Interop.add_constraintex(_lp, count, row, colno, constr_type, rh);
-        }
-
-        /// <summary>
-        /// Adds a constraint to the model.
-        /// </summary>
         /// <remarks>
         /// <para>This method adds a row to the model (at the end) and sets all values of the row at once.</para>
         /// <para>This method should only be used in small or demo code since it is not performant and uses more memory than <see cref="add_constraint"/> and <see cref="add_constraintex"/>.</para>
@@ -777,10 +781,6 @@
         /// <para>Note that if you have to add many constraints, performance can be improved by a call to <see cref="resize_lp"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_constraint.htm">Full C API documentation.</seealso>
-        /// <param name="row_string">A string with column elements that contains the values of the row. Each element must be separated by space(s).</param>
-        /// <param name="constr_type">The type of the constraint.</param>
-        /// <param name="rh">The value of the right-hand side (RHS) fo the constraint (in)equation</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool str_add_constraint(string row_string, lpsolve_constr_types constr_type, double rh)
         {
             return Interop.str_add_constraint(_lp, row_string, constr_type, rh);
@@ -789,6 +789,9 @@
         /// <summary>
         /// Removes a constraint from the model.
         /// </summary>
+        /// <param name="del_row">The row to delete. Must be between 1 and the number of rows in the model.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise. An error occurs when <paramref name="del_row"/>
+        /// is not between 1 and the number of rows in the model.</returns>
         /// <remarks>
         /// <para>Note that row entry mode must be off, else this function also fails. See <see cref="set_add_rowmode"/>.</para>
         /// <para>This method deletes a row from the model. The row is effectively deleted, so all rows after this row shift one up.</para>
@@ -796,8 +799,6 @@
         /// <para>Note that you can also delete multiple constraints by a call to <see cref="resize_lp"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/del_constraint.htm">Full C API documentation.</seealso>
-        /// <param name="del_row">The row to delete. Must be between 1 and the number of rows in the model.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise. An error occurs when <paramref name="del_row"/> is not between 1 and the number of rows in the model.</returns>
         public bool del_constraint(int del_row)
         {
             return Interop.del_constraint(_lp, del_row);
@@ -806,43 +807,45 @@
         /// <summary>
         /// Gets all row elements from the model for the given <paramref name="row_nr"/>.
         /// </summary>
+        /// <param name="row_nr">The row number of the matrix. Must be between 1 and number of rows in the model. Row 0 is the objective function.</param>
+        /// <param name="row">Array in which the values are returned. The array must be dimensioned with at least 1+<see cref="get_Ncolumns"/> elements.</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise. An error occurs when <paramref name="row_nr"/>
+        /// is not between 0 and the number of rows in the model.</returns>
         /// <remarks>
         /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
         /// <para>Element 0 of the row array is not filled. Element 1 will contain the value for column 1, Element 2 the value for column 2, ...</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_row.htm">Full C API documentation.</seealso>
-        /// <param name="row_nr">The row number of the matrix. Must be between 1 and number of rows in the model. Row 0 is the objective function.</param>
-        /// <param name="row">Array in which the values are returned. The array must be dimensioned with at least 1+<see cref="get_Ncolumns"/> elements.</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise. An error occurs when <paramref name="row_nr"/> is not between 0 and the number of rows in the model.</returns>
         public bool get_row(int row_nr, double[] row)
         {
             return Interop.get_row(_lp, row_nr, row);
         }

-
         /// <summary>
         /// Gets the non-zero row elements from the model for the given <paramref name="row_nr"/>.
         /// </summary>
-        /// <remarks>
-        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
-        /// <para>Returned values in <paramref name="row"/> and <paramref name="colno"/> start from element 0.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_row.htm">Full C API documentation.</seealso>
         /// <param name="row_nr">The row number of the matrix. Must be between 1 and number of rows in the model. Row 0 is the objective function.</param>
         /// <param name="row">Array in which the values are returned. The array must be dimensioned with at least the number of non-zero elements in the row.
         /// If that is unknown, then use the number of columns in the model. The return value of the method indicates how many non-zero elements there are.</param>
         /// <param name="colno">Array in which the column numbers are returned. The array must be dimensioned with at least the number of non-zero elements in the row.
         /// If that is unknown, then use the number of columns in the model. The return value of the method indicates how many non-zero elements there are.</param>
         /// <returns>The number of non-zero elements returned in <paramref name="row"/> and <paramref name="colno"/>. If an error occurs, then -1 is returned.. An error occurs when <paramref name="row_nr"/> is not between 0 and the number of rows in the model.</returns>
+        /// <remarks>
+        /// <para>Note that row entry mode must be off, else this method fails. <see cref="set_add_rowmode"/>.</para>
+        /// <para>Returned values in <paramref name="row"/> and <paramref name="colno"/> start from element 0.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_row.htm">Full C API documentation.</seealso>
         public int get_rowex(int row_nr, double[] row, int[] colno)
         {
             return Interop.get_rowex(_lp, row_nr, row, colno);
         }

-
         /// <summary>
         /// Sets a constraint in the model.
         /// </summary>
+        /// <param name="row_no">The row number that must be changed.</param>
+        /// <param name="row">An array with 1+<see cref="get_Ncolumns"/> elements that contains the values of the row.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>This method change the values of the row in the model at once.</para>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
@@ -851,17 +854,20 @@
         /// <para>Note that these routines will perform much better when <see cref="set_add_rowmode"/> is called before adding constraints.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_row.htm">Full C API documentation.</seealso>
+        public bool set_row(int row_no, double[] row)
+        {
+            return Interop.set_row(_lp, row_no, row);
+        }
+
+        /// <summary>
+        /// Sets a constraint in the model.
+        /// </summary>
         /// <param name="row_no">The row number that must be changed.</param>
-        /// <param name="row">An array with 1+<see cref="get_Ncolumns"/> elements that contains the values of the row.</param>
+        /// <param name="count">Number of elements in <paramref name="row"/> and <paramref name="colno"/>.</param>
+        /// <param name="row">An array with <paramref name="count"/> elements (or 1+<see cref="get_Ncolumns"/> elements if <paramref name="row"/> is <c>null</c>) that contains the values of the row.</param>
+        /// <param name="colno">An array with <paramref name="count"/> elements that contains the column numbers of the row. However this variable can also be <c>null</c>.
+        /// In that case element <c>i</c> in the variable row is column <c>i</c> and values start at element 1.</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
-        public bool set_row(int row_no, double[] row)
-        {
-            return Interop.set_row(_lp, row_no, row);
-        }
-
-        /// <summary>
-        /// Sets a constraint in the model.
-        /// </summary>
         /// <remarks>
         /// <para>This method change the values of the row in the model at once.</para>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
@@ -875,28 +881,21 @@
         /// <para>Note that these routines will perform much better when <see cref="set_add_rowmode"/> is called before adding constraints.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_row.htm">Full C API documentation.</seealso>
-        /// <param name="row_no">The row number that must be changed.</param>
-        /// <param name="count">Number of elements in <paramref name="row"/> and <paramref name="colno"/>.</param>
-        /// <param name="row">An array with <paramref name="count"/> elements (or 1+<see cref="get_Ncolumns"/> elements if <paramref name="row"/> is <c>null</c>) that contains the values of the row.</param>
-        /// <param name="colno">An array with <paramref name="count"/> elements that contains the column numbers of the row. However this variable can also be <c>null</c>.
-        /// In that case element <c>i</c> in the variable row is column <c>i</c> and values start at element 1.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool set_rowex(int row_no, int count, double[] row, int[] colno)
         {
             return Interop.set_rowex(_lp, row_no, count, row, colno);
         }

-
         /// <summary>
         /// Sets the name of a constraint (row) in the model.
         /// </summary>
-        /// <remarks>
-        /// <para>The row must already exist. row 0 is the objective function. Row names are optional.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_row_name.htm">Full C API documentation.</seealso>
         /// <param name="row">The row for which the name must be set. Must be between 0 and the number of rows in the model.</param>
         /// <param name="new_name">The name for the constraint (row).</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// <para>The row must already exist. row 0 is the objective function. Row names are optional.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_row_name.htm">Full C API documentation.</seealso>
         public bool set_row_name(int row, string new_name)
         {
             return Interop.set_row_name(_lp, row, new_name);
@@ -905,10 +904,6 @@
         /// <summary>
         /// Gets the name of a constraint (row) in the model.
         /// </summary>
-        /// <remarks>
-        /// <para>Row names are optional. If no row name was specified, the method returns Rx with x the row number. row 0 is the objective function.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_row_name.htm">Full C API documentation.</seealso>
         /// <param name="row">The row for which the name must be retrieved.
         /// Must be between 0 and the number of rows in the model. In <see cref="get_row_name"/>, row specifies the row number after presolve was done.
         /// In <see cref="get_origrow_name"/>, row specifies the row number before presolve was done, ie the original row number.</param>
@@ -918,6 +913,10 @@
         /// resolve can result in deletion of rows in the model. In <see cref="get_row_name"/>, row specifies the row number after presolve was done.
         /// In <see cref="get_origrow_name"/>, row specifies the row number before presolve was done, ie the original row number.
         /// If presolve is not active then both methods are equal.</returns>
+        /// <remarks>
+        /// <para>Row names are optional. If no row name was specified, the method returns Rx with x the row number. row 0 is the objective function.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_row_name.htm">Full C API documentation.</seealso>
         public string get_row_name(int row)
         {
             return Interop.get_row_name(_lp, row);
@@ -926,10 +925,6 @@
         /// <summary>
         /// Gets the name of a constraint (row) in the model.
         /// </summary>
-        /// <remarks>
-        /// <para>Row names are optional. If no row name was specified, the method returns Rx with x the row number. row 0 is the objective function.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_origrow_name.htm">Full C API documentation.</seealso>
         /// <param name="row">The row for which the name must be retrieved.
         /// Must be between 0 and the number of rows in the model. In <see cref="get_row_name"/>, row specifies the row number after presolve was done.
         /// In <see cref="get_origrow_name"/>, row specifies the row number before presolve was done, ie the original row number.</param>
@@ -939,6 +934,10 @@
         /// resolve can result in deletion of rows in the model. In <see cref="get_row_name"/>, row specifies the row number after presolve was done.
         /// In <see cref="get_origrow_name"/>, row specifies the row number before presolve was done, ie the original row number.
         /// If presolve is not active then both methods are equal.</returns>
+        /// <remarks>
+        /// <para>Row names are optional. If no row name was specified, the method returns Rx with x the row number. row 0 is the objective function.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_origrow_name.htm">Full C API documentation.</seealso>
         public string get_origrow_name(int row)
         {
             return Interop.get_origrow_name(_lp, row);
@@ -947,10 +946,10 @@
         /// <summary>
         /// Returns whether or not the constraint of the given row matches the given mask.
         /// </summary>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_constr_type.htm">Full C API documentation.</seealso>
         /// <param name="row">The row for which the constraint type must be retrieved. Must be between 1 and number of rows in the model.</param>
         /// <param name="mask">The type of the constraint to check in <paramref name="row"/></param>
         /// <returns><c>true</c> if the containt types match, <c>false</c> otherwise.</returns>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_constr_type.htm">Full C API documentation.</seealso>
         public bool is_constr_type(int row, lpsolve_constr_types mask)
         {
             return Interop.is_constr_type(_lp, row, mask);
@@ -959,10 +958,10 @@
         /// <summary>
         /// Gets the type of a constraint.
         /// </summary>
+        /// <param name="row">The row for which the constraint type must be retrieved. Must be between 1 and number of rows in the model.</param>
+        /// <returns>The type of the constraint on row <paramref name="row"/>.</returns>
         /// <remarks>The default constraint type is <see cref="lpsolve_constr_types.LE"/>.</remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_constr_type.htm">Full C API documentation.</seealso>
-        /// <param name="row">The row for which the constraint type must be retrieved. Must be between 1 and number of rows in the model.</param>
-        /// <returns>The type of the constraint on row <paramref name="row"/>.</returns>
         public lpsolve_constr_types get_constr_type(int row)
         {
             return Interop.get_constr_type(_lp, row);
@@ -971,6 +970,9 @@
         /// <summary>
         /// Sets the type of a constraint for the specified row.
         /// </summary>
+        /// <param name="row">The row for which the constraint type must be set. Must be between 1 and number of rows in the model.</param>
+        /// <param name="con_type">The type of the constraint.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>The default constraint type is <see cref="lpsolve_constr_types.LE"/>.</para>
         /// <para>A free constraint (<see cref="lpsolve_constr_types.FR"/>) will act as if the constraint is not there.
@@ -979,24 +981,20 @@
         /// .Note that the already set RHS and range on this constraint is overruled with Infinity by this.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_constr_type.htm">Full C API documentation.</seealso>
-        /// <param name="row">The row for which the constraint type must be set. Must be between 1 and number of rows in the model.</param>
-        /// <param name="con_type">The type of the constraint.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool set_constr_type(int row, lpsolve_constr_types con_type)
         {
             return Interop.set_constr_type(_lp, row, con_type);
         }

-
         /// <summary>
         /// Gets the value of the right hand side (RHS) vector (column 0) for one row.
         /// </summary>
-        /// <remarks>
-        /// <para>Note that row can also be 0 with this method. In that case it returns the initial value of the objective function.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_rh.htm">Full C API documentation.</seealso>
         /// <param name="row">The row number of the constraint on which the range must be retrieved. Must be between 1 and number of rows in the model.</param>
         /// <returns>The value of the RHS for the specified row. If row is out of range it returns 0. If no previous value was set, then it also returns 0, the default RHS value.</returns>
+        /// <remarks>
+        /// <para>Note that row can also be 0 with this method. In that case it returns the initial value of the objective function.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_rh.htm">Full C API documentation.</seealso>
         public double get_rh(int row)
         {
             return Interop.get_rh(_lp, row);
@@ -1005,6 +1003,9 @@
         /// <summary>
         /// Sets the value of the right hand side (RHS) vector (column 0) for the specified row.
         /// </summary>
+        /// <param name="row">The row for which the RHS value must be set. Must be between 1 and number of rows in the model.</param>
+        /// <param name="value">The value of the RHS.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>Note that row can also be 0 with this method.
         /// In that case an initial value for the objective value is set.
@@ -1012,18 +1013,16 @@
         /// but it is possible to first call one of these methods and then set the value of the objective with <see cref="set_rh"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_rh.htm">Full C API documentation.</seealso>
-        /// <param name="row">The row for which the RHS value must be set. Must be between 1 and number of rows in the model.</param>
-        /// <param name="value">The value of the RHS.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool set_rh(int row, double value)
         {
             return Interop.set_rh(_lp, row, value);
         }

-
         /// <summary>
         /// Gets the range on the constraint (row) identified by <paramref name="row"/>.
         /// </summary>
+        /// <param name="row">The row number of the constraint on which the range must be retrieved. Must be between 1 and number of rows in the model.</param>
+        /// <returns>The range on the constraint (row) identified by <paramref name="row"/>.</returns>
         /// <remarks>
         /// <para>Setting a range on a row is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a range doesn't increase the model size that means that the model stays smaller and will be solved faster.</para>
@@ -1033,8 +1032,6 @@
         /// <para>If no range was set then <see cref="get_rh_range"/> returns a very big number, the value of <see cref="get_infinite"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_rh_range.htm">Full C API documentation.</seealso>
-        /// <param name="row">The row number of the constraint on which the range must be retrieved. Must be between 1 and number of rows in the model.</param>
-        /// <returns>The range on the constraint (row) identified by <paramref name="row"/>.</returns>
         public double get_rh_range(int row)
         {
             return Interop.get_rh_range(_lp, row);
@@ -1043,6 +1040,9 @@
         /// <summary>
         /// Sets the range on the constraint (row) identified by <paramref name="row"/>.
         /// </summary>
+        /// <param name="row">The row number of the constraint on which the range must be set. Must be between 1 and number of rows in the model.</param>
+        /// <param name="deltavalue">The range on the constraint.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>Setting a range on a row is the way to go instead of adding an extra constraint (row) to the model.
         /// Setting a range doesn't increase the model size that means that the model stays smaller and will be solved faster.</para>
@@ -1051,9 +1051,6 @@
         /// <para>Note that the range value is the difference value and not the absolute value.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_rh_range.htm">Full C API documentation.</seealso>
-        /// <param name="row">The row number of the constraint on which the range must be set. Must be between 1 and number of rows in the model.</param>
-        /// <param name="deltavalue">The range on the constraint.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool set_rh_range(int row, double deltavalue)
         {
             return Interop.set_rh_range(_lp, row, deltavalue);
@@ -1062,13 +1059,13 @@
         /// <summary>
         /// Sets the value of the right hand side (RHS) vector (column 0).
         /// </summary>
+        /// <param name="rh">An array with row elements that contains the values of the RHS.</param>
         /// <remarks>
         /// <para>The method sets all values of the RHS vector (column 0) at once.</para>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Row 1 is element 1, row 2 is element 2, ...</para>
         /// <para>If the initial value of the objective function must also be set, use <see cref="set_rh"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_rh_vec.htm">Full C API documentation.</seealso>
-        /// <param name="rh">An array with row elements that contains the values of the RHS.</param>
         public void set_rh_vec(double[] rh)
         {
             Interop.set_rh_vec(_lp, rh);
@@ -1077,26 +1074,29 @@
         /// <summary>
         /// Sets the value of the right hand side (RHS) vector (column 0).
         /// </summary>
+        /// <param name="rh_string">A string with row elements that contains the values of the RHS. Each element must be separated by space(s).</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>The method sets all values of the RHS vector (column 0) at once.</para>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Row 1 is element 1, row 2 is element 2, ...</para>
         /// <para>If the initial value of the objective function must also be set, use <see cref="set_rh"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_rh_vec.htm">Full C API documentation.</seealso>
-        /// <param name="rh_string">A string with row elements that contains the values of the RHS. Each element must be separated by space(s).</param>
+        public bool str_set_rh_vec(string rh_string)
+        {
+            return Interop.str_set_rh_vec(_lp, rh_string);
+        }
+
+        #endregion
+
+        #region Objective
+
+        /// <summary>
+        /// Sets the objective function (row 0) of the matrix.
+        /// </summary>
+        /// <param name="column">The column number for which the value must be set.</param>
+        /// <param name="value">The value that must be set.</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
-        public bool str_set_rh_vec(string rh_string)
-        {
-            return Interop.str_set_rh_vec(_lp, rh_string);
-        }
-
-#endregion
-
-#region Objective
-
-        /// <summary>
-        /// Sets the objective function (row 0) of the matrix.
-        /// </summary>
         /// <remarks>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
         /// <para>It is better to use <see cref="set_obj_fnex"/> or <see cref="set_obj_fn"/>.</para>
@@ -1104,9 +1104,6 @@
         /// This especially for larger models. This will be much more performant than adding the objective function afterwards.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_obj_fn.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number for which the value must be set.</param>
-        /// <param name="value">The value that must be set.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool set_obj(int column, double value)
         {
             return Interop.set_obj(_lp, column, value);
@@ -1115,12 +1112,12 @@
         /// <summary>
         /// Returns initial "at least better than" guess for objective function.
         /// </summary>
+        /// <returns>Returns initial "at least better than" guess for objective function.</returns>
         /// <remarks>
         /// <para>This is only used in the branch-and-bound algorithm when integer variables exist in the model. All solutions with a worse objective value than this value are immediately rejected. This can result in faster solving times, but it can be difficult to predict what value to take for this bound. Also there is the chance that the found solution is not the most optimal one.</para>
         /// <para>The default is infinite.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_obj_bound.htm">Full C API documentation.</seealso>
-        /// <returns>Returns initial "at least better than" guess for objective function.</returns>
         public double get_obj_bound()
         {
             return Interop.get_obj_bound(_lp);
@@ -1129,6 +1126,7 @@
         /// <summary>
         /// Sets initial "at least better than" guess for objective function.
         /// </summary>
+        /// <param name="obj_bound">The initial "at least better than" guess for objective function.</param>
         /// <remarks>
         /// <para>This is only used in the branch-and-bound algorithm when integer variables exist in the model.
         /// All solutions with a worse objective value than this value are immediately rejected.
@@ -1137,7 +1135,6 @@
         /// <para>The default is infinite.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_obj_bound.htm">Full C API documentation.</seealso>
-        /// <param name="obj_bound">The initial "at least better than" guess for objective function.</param>
         public void set_obj_bound(double obj_bound)
         {
             Interop.set_obj_bound(_lp, obj_bound);
@@ -1146,6 +1143,8 @@
         /// <summary>
         /// Sets the objective function (row 0) of the matrix.
         /// </summary>
+        /// <param name="row">An array with 1+<see cref="get_Ncolumns"/> elements that contains the values of the objective function.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>This method set the values of the objective function in the model at once.</para>
         /// <para>Note that element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
@@ -1155,16 +1154,18 @@
         /// This especially for larger models. This will be much more performant than adding the objective function afterwards.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_obj_fn.htm">Full C API documentation.</seealso>
-        /// <param name="row">An array with 1+<see cref="get_Ncolumns"/> elements that contains the values of the objective function.</param>
+        public bool set_obj_fn(double[] row)
+        {
+            return Interop.set_obj_fn(_lp, row);
+        }
+
+        /// <summary>
+        /// Sets the objective function (row 0) of the matrix.
+        /// </summary>
+        /// <param name="count">Number of elements in <paramref name="row"/> and <paramref name="colno"/>.</param>
+        /// <param name="row">An array with <paramref name="count"/> elements (or 1+<see cref="get_Ncolumns"/> elements if <paramref name="row"/> is <c>null</c>) that contains the values of the row.</param>
+        /// <param name="colno">An array with <paramref name="count"/> elements that contains the column numbers of the row. However this variable can also be <c>null</c>.</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
-        public bool set_obj_fn(double[] row)
-        {
-            return Interop.set_obj_fn(_lp, row);
-        }
-
-        /// <summary>
-        /// Sets the objective function (row 0) of the matrix.
-        /// </summary>
         /// <remarks>
         /// <para>This method set the values of the objective function in the model at once.</para>
         /// <para>Note that when <paramref name="colno"/> is <c>null</c> element 0 of the array is not considered (i.e. ignored). Column 1 is element 1, column 2 is element 2, ...</para>
@@ -1176,25 +1177,21 @@
         /// This especially for larger models. This will be much more performant than adding the objective function afterwards.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_obj_fn.htm">Full C API documentation.</seealso>
-        /// <param name="count">Number of elements in <paramref name="row"/> and <paramref name="colno"/>.</param>
-        /// <param name="row">An array with <paramref name="count"/> elements (or 1+<see cref="get_Ncolumns"/> elements if <paramref name="row"/> is <c>null</c>) that contains the values of the row.</param>
-        /// <param name="colno">An array with <paramref name="count"/> elements that contains the column numbers of the row. However this variable can also be <c>null</c>.</param>
+        public bool set_obj_fnex(int count, double[] row, int[] colno)
+        {
+            return Interop.set_obj_fnex(_lp, count, row, colno);
+        }
+
+        /// <summary>
+        /// Sets the objective function (row 0) of the matrix.
+        /// </summary>
+        /// <param name="row_string">A string with column elements that contains the values of the objective function. Each element must be separated by space(s).</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
-        public bool set_obj_fnex(int count, double[] row, int[] colno)
-        {
-            return Interop.set_obj_fnex(_lp, count, row, colno);
-        }
-
-        /// <summary>
-        /// Sets the objective function (row 0) of the matrix.
-        /// </summary>
         /// <remarks>
         /// <para>This method set the values of the objective function in the model at once.</para>
         /// <para>This method should only be used in small or demo code since it is not performant and uses more memory than <see cref="set_obj_fnex"/> or <see cref="set_obj_fn"/></para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_obj_fn.htm">Full C API documentation.</seealso>
-        /// <param name="row_string">A string with column elements that contains the values of the objective function. Each element must be separated by space(s).</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool str_set_obj_fn(string row_string)
         {
             return Interop.str_set_obj_fn(_lp, row_string);
@@ -1203,11 +1200,11 @@
         /// <summary>
         /// Returns objective function direction.
         /// </summary>
+        /// <returns><c>true</c> if the objective function is maximize, <c>false</c> if it is minimize.</returns>
         /// <remarks>
         /// The default of lp_solve is to minimize, except for <see cref="read_LP"/> where the default is to maximize.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_maxim.htm">Full C API documentation.</seealso>
-        /// <returns><c>true</c> if the objective function is maximize, <c>false</c> if it is minimize.</returns>
         public bool is_maxim()
         {
             return Interop.is_maxim(_lp);
@@ -1240,26 +1237,26 @@
         /// <summary>
         /// Sets the objective function sense.
         /// </summary>
+        /// <param name="maximize">When <c>true</c>, the objective function sense is maximize, when <c>false</c> it is minimize.</param>
         /// <remarks>
         /// The default of lp_solve is to minimize, except for <see cref="read_LP"/> where the default is to maximize.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_sense.htm">Full C API documentation.</seealso>
-        /// <param name="maximize">When <c>true</c>, the objective function sense is maximize, when <c>false</c> it is minimize.</param>
         public void set_sense(bool maximize)
         {
             Interop.set_sense(_lp, maximize);
         }

-#endregion
+        #endregion

         /// <summary>
         /// Gets the name of the model.
         /// </summary>
+        /// <returns>The name of the model.</returns>
         /// <remarks>
         /// Giving the lp a name is optional. The default name is "Unnamed".
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_lp_name.htm">Full C API documentation.</seealso>
-        /// <returns>The name of the model.</returns>
         public string get_lp_name()
         {
             return Interop.get_lp_name(_lp);
@@ -1268,12 +1265,12 @@
         /// <summary>
         /// Sets the name of the model.
         /// </summary>
-        /// <remarks>
-        /// Giving the lp a name is optional. The default name is "Unnamed".
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_lp_name.htm">Full C API documentation.</seealso>
         /// <param name="lpname">The name of the model.</param>
         /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// Giving the lp a name is optional. The default name is "Unnamed".
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_lp_name.htm">Full C API documentation.</seealso>
         public bool set_lp_name(string lpname)
         {
             return Interop.set_lp_name(_lp, lpname);
@@ -1282,6 +1279,9 @@
         /// <summary>
         /// Allocates memory for the specified size.
         /// </summary>
+        /// <param name="rows">Allocates memory for this amount of rows.</param>
+        /// <param name="columns">Allocates memory for this amount of columns.</param>
+        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>This method deletes the last rows/columns of the model if the new number of rows/columns is less than the number of rows/columns before the call.</para>
         /// <para>However, the function does **not** add rows/columns to the model if the new number of rows/columns is larger.
@@ -1292,9 +1292,6 @@
         /// must be done only once resulting in better performance. So if the number of rows/columns that will be added is known in advance, then performance can be improved by using this function.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/resize_lp.htm">Full C API documentation.</seealso>
-        /// <param name="rows">Allocates memory for this amount of rows.</param>
-        /// <param name="columns">Allocates memory for this amount of columns.</param>
-        /// <returns><c>true</c> if operation was successful, <c>false</c> otherwise.</returns>
         public bool resize_lp(int rows, int columns)
         {
             return Interop.resize_lp(_lp, rows, columns);
@@ -1304,6 +1301,9 @@
         /// Returns a flag telling which of the add methods perform best. Whether <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>
         /// or <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>.
         /// </summary>
+        /// <returns>If <c>false</c> then <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>
+        /// perform best. If <c>true</c> then <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>
+        /// perform best.</returns>
         /// <remarks>
         /// <para>Default, this is <c>false</c>, meaning that <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/> perform best.
         /// If the model is build via <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/> calls,
@@ -1326,9 +1326,6 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_add_rowmode.htm">Full C API documentation.</seealso>
-        /// <returns>If <c>false</c> then <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>
-        /// perform best. If <c>true</c> then <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>
-        /// perform best.</returns>
         public bool is_add_rowmode()
         {
             return Interop.is_add_rowmode(_lp);
@@ -1338,6 +1335,10 @@
         /// Specifies which add methods perform best. Whether <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>
         /// or <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>.
         /// </summary>
+        /// <param name="turnon">If <c>false</c> then <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>
+        /// perform best. If <c>true</c> then <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>
+        /// perform best.</param>
+        /// <returns><c>true</c> if the rowmode was changed, <c>false</c> if the given mode was already set.</returns>
         /// <remarks>
         /// <para>Default, this is <c>false</c>, meaning that <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/> perform best.
         /// If the model is build via <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/> calls,
@@ -1360,10 +1361,6 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_add_rowmode.htm">Full C API documentation.</seealso>
-        /// <param name="turnon">If <c>false</c> then <see cref="add_column"/>, <see cref="add_columnex"/>, <see cref="str_add_column"/>
-        /// perform best. If <c>true</c> then <see cref="add_constraint"/>, <see cref="add_constraintex"/>, <see cref="str_add_constraint"/>
-        /// perform best.</param>
-        /// <returns><c>true</c> if the rowmode was changed, <c>false</c> if the given mode was already set.</returns>
         public bool set_add_rowmode(bool turnon)
         {
             return Interop.set_add_rowmode(_lp, turnon);
@@ -1372,11 +1369,6 @@
         /// <summary>
         /// Gets the index of a given column or row name in the model.
         /// </summary>
-        /// <remarks>
-        /// Note that this index starts from 1.
-        /// Some API routines expect zero-based indexes and thus this value must then be corrected with -1.
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_nameindex.htm">Full C API documentation.</seealso>
         /// <param name="name">The name of the column or row for which the index (column/row number) must be retrieved.</param>
         /// <param name="isrow">Use <c>false</c> when column information is needed and <c>true</c> when row information is needed.</param>
         /// <returns>Returns the index (column/row number) of the given column/row name.
@@ -1384,6 +1376,11 @@
         /// Note that the index is the original index number.
         /// So if presolve is active, it has no effect.
         /// It is the original column/row number that is returned.</returns>
+        /// <remarks>
+        /// Note that this index starts from 1.
+        /// Some API routines expect zero-based indexes and thus this value must then be corrected with -1.
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_nameindex.htm">Full C API documentation.</seealso>
         public int get_nameindex(string name, bool isrow)
         {
             return Interop.get_nameindex(_lp, name, isrow);
@@ -1392,12 +1389,12 @@
         /// <summary>
         /// Returns the value of "infinite".
         /// </summary>
+        /// <returns>Returns the practical value of "infinite".</returns>
         /// <remarks>
         /// <para>This value is used for very big numbers. For example the upper bound of a variable without an upper bound.</para>
         /// <para>The default is 1e30</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_infinite.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the practical value of "infinite".</returns>
         public double get_infinite()
         {
             return Interop.get_infinite(_lp);
@@ -1406,12 +1403,12 @@
         /// <summary>
         /// Specifies the practical value of "infinite".
         /// </summary>
+        /// <param name="infinite">The value that must be used for "infinite".</param>
         /// <remarks>
         /// <para>This value is used for very big numbers. For example the upper bound of a variable without an upper bound.</para>
         /// <para>The default is 1e30</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_infinite.htm">Full C API documentation.</seealso>
-        /// <param name="infinite">The value that must be used for "infinite".</param>
         public void set_infinite(double infinite)
         {
             Interop.set_infinite(_lp, infinite);
@@ -1420,12 +1417,12 @@
         /// <summary>
         /// Checks if the provided absolute of the value is larger or equal to "infinite".
         /// </summary>
-        /// <remarks>
-        /// Note that the absolute of the provided value is checked against the value set by <see cref="set_infinite"/>.
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_infinite.htm">Full C API documentation.</seealso>
         /// <param name="value">The value to check against "infinite".</param>
         /// <returns><c>true</c> if the value is equal or larger to "infinite", <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// Note that the absolute of the provided value is checked against the value set by <see cref="set_infinite"/>.
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_infinite.htm">Full C API documentation.</seealso>
         public bool is_infinite(double value)
         {
             return Interop.is_infinite(_lp, value);
@@ -1434,14 +1431,6 @@
         /// <summary>
         /// Gets a single element from the matrix.
         /// </summary>
-        /// <remarks>
-        /// <para>This function is not efficient if many values are to be retrieved.
-        /// Consider to use <see cref="get_row"/>, <see cref="get_rowex"/>, <see cref="get_column"/>, <see cref="get_columnex"/>.</para>
-        /// <para>
-        /// If row and/or column are outside the allowed range, the function returns 0.
-        /// </para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_mat.htm">Full C API documentation.</seealso>
         /// <param name="row">Row number of the matrix. Must be between 0 and number of rows in the model. Row 0 is objective function.</param>
         /// <param name="column">Column number of the matrix. Must be between 1 and number of columns in the model.</param>
         /// <returns>
@@ -1449,6 +1438,14 @@
         /// If no value was set for this element, the function returns 0.</para>
         /// <para>Note that row entry mode must be off, else this function also fails.
         /// See <see cref="set_add_rowmode"/>.</para></returns>
+        /// <remarks>
+        /// <para>This function is not efficient if many values are to be retrieved.
+        /// Consider to use <see cref="get_row"/>, <see cref="get_rowex"/>, <see cref="get_column"/>, <see cref="get_columnex"/>.</para>
+        /// <para>
+        /// If row and/or column are outside the allowed range, the function returns 0.
+        /// </para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_mat.htm">Full C API documentation.</seealso>
         public double get_mat(int row, int column)
         {
             return Interop.get_mat(_lp, row, column);
@@ -1457,6 +1454,12 @@
         /// <summary>
         /// Sets a single element in the matrix.
         /// </summary>
+        /// <param name="row">Row number of the matrix. Must be between 0 and number of rows in the model. Row 0 is objective function.</param>
+        /// <param name="column">Column number of the matrix. Must be between 1 and number of columns in the model.</param>
+        /// <param name="value">Value to set on row <paramref name="row"/>, column <paramref name="column"/>.</param>
+        /// <returns><para><c>true</c> if operation was successful, <c>false</c> otherwise.</para>
+        /// <para>Note that row entry mode must be off, else this function also fails.
+        /// See <see cref="set_add_rowmode"/>.</para></returns>
         /// <remarks>
         /// <para>If there was already a value for this element, it is replaced and if there was no value, it is added.</para>
         /// <para>This function is not efficient if many values are to be set.
@@ -1469,12 +1472,6 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_mat.htm">Full C API documentation.</seealso>
-        /// <param name="row">Row number of the matrix. Must be between 0 and number of rows in the model. Row 0 is objective function.</param>
-        /// <param name="column">Column number of the matrix. Must be between 1 and number of columns in the model.</param>
-        /// <param name="value">Value to set on row <paramref name="row"/>, column <paramref name="column"/>.</param>
-        /// <returns><para><c>true</c> if operation was successful, <c>false</c> otherwise.</para>
-        /// <para>Note that row entry mode must be off, else this function also fails.
-        /// See <see cref="set_add_rowmode"/>.</para></returns>
         public bool set_mat(int row, int column, double value)
         {
             return Interop.set_mat(_lp, row, column, value);
@@ -1483,6 +1480,7 @@
         /// <summary>
         /// Specifies if set bounds may only be tighter or also less restrictive.
         /// </summary>
+        /// <param name="tighten">Specifies if set bounds may only be tighter <c>true</c> or also less restrictive <c>false</c>.</param>
         /// <remarks>
         /// <para>If set to <c>true</c> then bounds may only be tighter.
         /// This means that when <see cref="set_lowbo"/> or <see cref="set_lowbo"/> is used to set a bound
@@ -1494,7 +1492,6 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_bounds_tighter.htm">Full C API documentation.</seealso>
-        /// <param name="tighten">Specifies if set bounds may only be tighter <c>true</c> or also less restrictive <c>false</c>.</param>
         public void set_bounds_tighter(bool tighten)
         {
             Interop.set_bounds_tighter(_lp, tighten);
@@ -1503,6 +1500,7 @@
         /// <summary>
         /// Returns if set bounds may only be tighter or also less restrictive.
         /// </summary>
+        /// <returns>Returns <c>true</c> if set bounds may only be tighter or <c>false</c> if they can also be less restrictive.</returns>
         /// <remarks>
         /// <para>If it returns <c>true</c> then bounds may only be tighter.
         /// This means that when <see cref="set_lowbo"/> or <see cref="set_lowbo"/> is used to set a bound
@@ -1514,7 +1512,6 @@
         /// </para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_bounds_tighter.htm">Full C API documentation.</seealso>
-        /// <returns>Returns <c>true</c> if set bounds may only be tighter or <c>false</c> if they can also be less restrictive.</returns>
         public bool get_bounds_tighter()
         {
             return Interop.get_bounds_tighter(_lp);
@@ -1523,15 +1520,15 @@
         /// <summary>
         /// Returns, for the specified variable, the priority the variable has in the branch-and-bound algorithm.
         /// </summary>
+        /// <param name="column">The column number of the variable on which the priority must be returned.
+        /// It must be between 1 and the number of columns in the model. If it is not within this range, the return value is 0.</param>
+        /// <returns>Returns the priority of the variable.</returns>
         /// <remarks>
         /// The method returns the priority the variable has in the branch-and-bound algorithm.
         /// This priority is determined by the weights set by <see cref="set_var_weights"/>.
         /// The default priorities are the column positions of the variables in the model.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_var_priority.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable on which the priority must be returned.
-        /// It must be between 1 and the number of columns in the model. If it is not within this range, the return value is 0.</param>
-        /// <returns>Returns the priority of the variable.</returns>
         public int get_var_priority(int column)
         {
             return Interop.get_var_priority(_lp, column);
@@ -1540,6 +1537,8 @@
         /// <summary>
         /// Sets the weights on variables.
         /// </summary>
+        /// <param name="weights">The weights array.</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>The <see cref="set_var_weights"/> sets a weight factor on each variable.
         /// This is only used for the integer variables in the branch-and-bound algorithm.
@@ -1550,8 +1549,6 @@
         /// The lower the weight, the sooner the variable is chosen to make it integer.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_var_weights.htm">Full C API documentation.</seealso>
-        /// <param name="weights">The weights array.</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
         public bool set_var_weights(double[] weights)
         {
             return Interop.set_var_weights(_lp, weights);
@@ -1560,11 +1557,6 @@
         /// <summary>
         /// Adds a SOS (Special Ordered Sets) constraint.
         /// </summary>
-        /// <remarks>
-        /// <para>The <see cref="add_SOS"/> function adds an SOS constraint.</para>
-        /// <para>See <see href="http://lpsolve.sourceforge.net/5.5/SOS.htm">Special Ordered Sets</see> for a description about SOS variables.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_SOS.htm">Full C API documentation.</seealso>
         /// <param name="name">The name of the SOS constraint.</param>
         /// <param name="sostype">The type of the SOS constraint. Must be >= 1</param>
         /// <param name="priority">Priority of the SOS constraint in the SOS set.</param>
@@ -1574,6 +1566,11 @@
         /// In that case, lp_solve will weight the variables in the order they are specified.</param>
         /// <returns>Returns the list index of the new SOS if the operation was successful.
         /// A return value of 0 indicates an error.</returns>
+        /// <remarks>
+        /// <para>The <see cref="add_SOS"/> function adds an SOS constraint.</para>
+        /// <para>See <see href="http://lpsolve.sourceforge.net/5.5/SOS.htm">Special Ordered Sets</see> for a description about SOS variables.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_SOS.htm">Full C API documentation.</seealso>
         public int add_SOS(string name, int sostype, int priority, int count, int[] sosvars, double[] weights)
         {
             return Interop.add_SOS(_lp, name, sostype, priority, count, sosvars, weights);
@@ -1582,34 +1579,34 @@
         /// <summary>
         /// Returns if the variable is SOS (Special Ordered Set) or not.
         /// </summary>
+        /// <param name="column">The column number of the variable that must be checked.
+        /// It must be between 1 and the number of columns in the model.</param>
+        /// <returns><c>true</c> if variable is a SOS var, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>The <see cref="is_SOS_var "/> method returns if a variable is a SOS variable or not.
         /// Default a variable is not SOS. A variable becomes a SOS variable via <see cref="add_SOS"/>.</para>
         /// <para>See <see href="http://lpsolve.sourceforge.net/5.5/SOS.htm">Special Ordered Sets</see> for a description about SOS variables.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/add_SOS.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable that must be checked.
-        /// It must be between 1 and the number of columns in the model.</param>
-        /// <returns><c>true</c> if variable is a SOS var, <c>false</c> otherwise.</returns>
         public bool is_SOS_var(int column)
         {
             return Interop.is_SOS_var(_lp, column);
         }

-#endregion
-
-#region Solver settings
-
-#region Epsilon / Tolerance
+        #endregion
+
+        #region Solver settings
+
+        #region Epsilon / Tolerance

         /// <summary>
         /// Returns the value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0.
         /// </summary>
+        /// <returns>Returns the value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0.</returns>
         /// <remarks>
         /// The default value for <c>epsb</c> is <c>1e-10</c>.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_epsb.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0.</returns>
         public double get_epsb()
         {
             return Interop.get_epsb(_lp);
@@ -1618,13 +1615,13 @@
         /// <summary>
         /// Specifies the value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0.
         /// </summary>
+        /// <param name="epsb">The value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0.</param>
         /// <remarks>
         /// <para>Floating-point calculations always result in loss of precision and rounding errors.
         /// Therefore a very small value (example <c>1e-99</c>) could be the result of such errors and should be considered as 0 for the algorithm. epsb specifies the tolerance to determine if a RHS value should be considered as 0. If abs(value) is less than this epsb value in the RHS, it is considered as 0.</para>
         /// <para>The default <c>epsb</c> value is <c>1e-10</c></para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epsb.htm">Full C API documentation.</seealso>
-        /// <param name="epsb">The value that is used as a tolerance for the Right Hand Side (RHS) to determine whether a value should be considered as 0.</param>
         public void set_epsb(double epsb)
         {
             Interop.set_epsb(_lp, epsb);
@@ -1633,11 +1630,11 @@
         /// <summary>
         /// Returns the value that is used as a tolerance for the reduced costs to determine whether a value should be considered as 0.
         /// </summary>
+        /// <returns>Returns the value that is used as a tolerance for the reduced costs to determine whether a value should be considered as 0.</returns>
         /// <remarks>
         /// The default value for <c>epsd</c> is <c>1e-9</c>.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_epsd.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the value that is used as a tolerance for the reduced costs to determine whether a value should be considered as 0.</returns>
         public double get_epsd()
         {
             return Interop.get_epsd(_lp);
@@ -1646,13 +1643,13 @@
         /// <summary>
         /// Specifies the value that is used as a tolerance for reduced costs to determine whether a value should be considered as 0.
         /// </summary>
+        /// <param name="epsd">The value that is used as a tolerance for reduced costs to determine whether a value should be considered as 0.</param>
         /// <remarks>
         /// <para>Floating-point calculations always result in loss of precision and rounding errors.
         /// Therefore a very small value (example <c>1e-99</c>) could be the result of such errors and should be considered as 0 for the algorithm. epsd specifies the tolerance to determine if a reducedcost value should be considered as 0. If abs(value) is less than this epsd value, it is considered as 0.</para>
         /// <para>The default <c>epsd</c> value is <c>1e-9</c></para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epsd.htm">Full C API documentation.</seealso>
-        /// <param name="epsd">The value that is used as a tolerance for reduced costs to determine whether a value should be considered as 0.</param>
         public void set_epsd(double epsd)
         {
             Interop.set_epsd(_lp, epsd);
@@ -1661,12 +1658,12 @@
         /// <summary>
         /// Returns the value that is used as a tolerance for rounding values to zero.
         /// </summary>
+        /// <returns>Returns the value that is used as a tolerance for rounding values to zero.</returns>
         /// <remarks>
         /// <para><c>epsel</c> is used on all other places where <c>epsint</c>, <c>epsb</c>, <c>epsd</c>, <c>epspivot</c>, <c>epsperturb</c> are not used.</para>
         /// <para>The default value for <c>epsel</c> is <c>1e-12</c></para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_epsel.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the value that is used as a tolerance for rounding values to zero.</returns>
         public double get_epsel()
         {
             return Interop.get_epsel(_lp);
@@ -1675,13 +1672,13 @@
         /// <summary>
         /// Specifies the value that is used as a tolerance for rounding values to zero.
         /// </summary>
+        /// <param name="epsel">The value that is used as a tolerance for rounding values to zero.</param>
         /// <remarks>
         /// <para>Floating-point calculations always result in loss of precision and rounding errors. Therefore a very small value (example 1e-99) could be the result of such errors and should be considered as 0 for the algorithm. epsel specifies the tolerance to determine if a value should be considered as 0. If abs(value) is less than this epsel value, it is considered as 0.</para>
         /// <para><c>epsel</c> is used on all other places where <c>epsint</c>, <c>epsb</c>, <c>epsd</c>, <c>epspivot</c>, <c>epsperturb</c> are not used.</para>
         /// <para>The default value for <c>epsel</c> is <c>1e-12</c></para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epsel.htm">Full C API documentation.</seealso>
-        /// <param name="epsel">The value that is used as a tolerance for rounding values to zero.</param>
         public void set_epsel(double epsel)
         {
             Interop.set_epsel(_lp, epsel);
@@ -1690,11 +1687,11 @@
         /// <summary>
         /// Returns the tolerance that is used to determine whether a floating-point number is in fact an integer.
         /// </summary>
+        /// <returns>Returns the tolerance that is used to determine whether a floating-point number is in fact an integer.</returns>
         /// <remarks>
         /// The default value for <c>epsint</c> is <c>1e-7</c>.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_epsint.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the tolerance that is used to determine whether a floating-point number is in fact an integer.</returns>
         public double get_epsint()
         {
             return Interop.get_epsint(_lp);
@@ -1703,6 +1700,7 @@
         /// <summary>
         /// Specifies the tolerance that is used to determine whether a floating-point number is in fact an integer.
         /// </summary>
+        /// <param name="epsint">The tolerance that is used to determine whether a floating-point number is in fact an integer.</param>
         /// <remarks>
         /// <para>This is only used when there is at least one integer variable and the branch and bound algorithm is used to make variables integer.</para>
         /// <para>Integer variables are internally in the algorithm also stored as floating point.
@@ -1715,7 +1713,6 @@
         /// <para>So it is a compromise.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epsint.htm">Full C API documentation.</seealso>
-        /// <param name="epsint">The tolerance that is used to determine whether a floating-point number is in fact an integer.</param>
         public void set_epsint(double epsint)
         {
             Interop.set_epsint(_lp, epsint);
@@ -1724,9 +1721,9 @@
         /// <summary>
         /// Returns the value that is used as perturbation scalar for degenerative problems.
         /// </summary>
+        /// <returns>Returns the perturbation scalar.</returns>
         /// <remarks>The default epsperturb value is 1e-5</remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_epsperturb.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the perturbation scalar.</returns>
         public double get_epsperturb()
         {
             return Interop.get_epsperturb(_lp);
@@ -1735,9 +1732,9 @@
         /// <summary>
         /// Specifies the value that is used as perturbation scalar for degenerative problems.
         /// </summary>
+        /// <param name="epsperturb">The perturbation scalar.</param>
         /// <remarks>The default epsperturb value is 1e-5</remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epsperturb.htm">Full C API documentation.</seealso>
-        /// <param name="epsperturb">The perturbation scalar.</param>
         public void set_epsperturb(double epsperturb)
         {
             Interop.set_epsperturb(_lp, epsperturb);
@@ -1746,6 +1743,7 @@
         /// <summary>
         /// Returns the value that is used as a tolerance for the pivot element to determine whether a value should be considered as 0.
         /// </summary>
+        /// <returns>Returns the value that is used as a tolerance for the pivot element to determine whether a value should be considered as 0.</returns>
         /// <remarks>
         /// <para>Floating-point calculations always result in loss of precision and rounding errors.
         /// Therefore a very small value (example 1e-99) could be the result of such errors and should be considered as 0
@@ -1755,7 +1753,6 @@
         /// <para>The default epspivot value is 2e-7</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_epspivot.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the value that is used as a tolerance for the pivot element to determine whether a value should be considered as 0.</returns>
         public double get_epspivot()
         {
             return Interop.get_epspivot(_lp);
@@ -1764,6 +1761,7 @@
         /// <summary>
         /// Specifies the value that is used as a tolerance pivot element to determine whether a value should be considered as 0.
         /// </summary>
+        /// <param name="epspivot">The value that is used as a tolerance for the pivot element to determine whether a value should be considered as 0.</param>
         /// <remarks>
         /// <para>Floating-point calculations always result in loss of precision and rounding errors.
         /// Therefore a very small value (example 1e-99) could be the result of such errors and should be considered as 0
@@ -1773,7 +1771,6 @@
         /// <para>The default epspivot value is 2e-7</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epspivot.htm">Full C API documentation.</seealso>
-        /// <param name="epspivot">The value that is used as a tolerance for the pivot element to determine whether a value should be considered as 0.</param>
         public void set_epspivot(double epspivot)
         {
             Interop.set_epspivot(_lp, epspivot);
@@ -1782,6 +1779,8 @@
         /// <summary>
         /// Specifies the MIP gap value.
         /// </summary>
+        /// <param name="absolute">If <c>true</c> then the absolute MIP gap is set, else the relative MIP gap.</param>
+        /// <param name="mip_gap">The MIP gap.</param>
         /// <remarks>
         /// <para>The set_mip_gap function sets the MIP gap that specifies a tolerance for the branch and bound algorithm.
         /// This tolerance is the difference between the best-found solution yet and the current solution.
@@ -1791,8 +1790,6 @@
         /// <para>The default is 1e-11.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_mip_gap.htm">Full C API documentation.</seealso>
-        /// <param name="absolute">If <c>true</c> then the absolute MIP gap is set, else the relative MIP gap.</param>
-        /// <param name="mip_gap">The MIP gap.</param>
         public void set_mip_gap(bool absolute, double mip_gap)
         {
             Interop.set_mip_gap(_lp, absolute, mip_gap);
@@ -1801,6 +1798,8 @@
         /// <summary>
         /// Returns the MIP gap value.
         /// </summary>
+        /// <param name="absolute">If <c>true</c> then the absolute MIP gap is returned, else the relative MIP gap.</param>
+        /// <returns>The MIP gap value</returns>
         /// <remarks>
         /// <para>The get_mip_gap function returns the MIP gap that specifies a tolerance for the branch and bound algorithm.
         /// This tolerance is the difference between the best-found solution yet and the current solution.
@@ -1810,8 +1809,6 @@
         /// <para>The default is 1e-11.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_mip_gap.htm">Full C API documentation.</seealso>
-        /// <param name="absolute">If <c>true</c> then the absolute MIP gap is returned, else the relative MIP gap.</param>
-        /// <returns></returns>
         public double get_mip_gap(bool absolute)
         {
             return Interop.get_mip_gap(_lp, absolute);
@@ -1820,21 +1817,21 @@
         /// <summary>
         /// This is a simplified way of specifying multiple eps thresholds that are "logically" consistent.
         /// </summary>
+        /// <param name="level">The level to set.</param>
+        /// <returns><c>true</c> if level is accepted and <c>false</c> if an invalid epsilon level was provided.</returns>
         /// <remarks>
         /// <para>It sets the following values: <see cref="set_epsel"/>, <see cref="set_epsb"/>, <see cref="set_epsd"/>, <see cref="set_epspivot"/>, <see cref="set_epsint"/>, <see cref="set_mip_gap"/>.</para>
         /// <para>The default is <see cref="lpsolve_epsilon_level.EPS_TIGHT"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_epslevel.htm">Full C API documentation.</seealso>
-        /// <param name="level">The level to set.</param>
-        /// <returns><c>true</c> if level is accepted and <c>false</c> if an invalid epsilon level was provided.</returns>
         public bool set_epslevel(lpsolve_epsilon_level level)
         {
             return Interop.set_epslevel(_lp, level);
         }

-#endregion
-
-#region Basis
+        #endregion
+
+        #region Basis
         /// <summary>
         /// Causes reinversion at next opportunity.
         /// </summary>
@@ -1859,8 +1856,8 @@

         /// <summary>
         /// Sets the starting base to an all slack basis (the default simplex starting basis).
+        /// </summary>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/default_basis.htm">Full C API documentation.</seealso>
-        /// </summary>
         public void default_basis()
         {
             Interop.default_basis(_lp);
@@ -1869,14 +1866,6 @@
         /// <summary>
         /// Read basis from a file and set as default basis.
         /// </summary>
-        /// <remarks>
-        /// <para>Setting an initial basis can speed up the solver considerably.
-        /// It is the starting point from where the algorithm continues to find an optimal solution.</para>
-        /// <para>When a restart is done, lp_solve continues at the last basis, except if <see cref="set_basis"/>,
-        /// <see cref="default_basis"/>, <see cref="guess_basis"/> or <see cref="read_basis"/> is called.</para>
-        /// <para>The basis in the file must be in <see href="http://lpsolve.sourceforge.net/5.5/bas-format.htm">MPS bas file format</see>.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_basis.htm">Full C API documentation.</seealso>
         /// <param name="filename">Name of file containing the basis to read.</param>
         /// <param name="info">When not <c>null</c>, returns the information of the INFO card in <paramref name="filename"/>.
         /// When <c>null</c>, the information is ignored.
@@ -1885,6 +1874,14 @@
         /// <returns><c>true</c> if basis could be read from <paramref name="filename"/> and <c>false</c> if not.
         /// A <c>false</c> return value indicates an error.
         /// Specifically file could not be opened or file has wrong structure or wrong number/names rows/variables or invalid basis.</returns>
+        /// <remarks>
+        /// <para>Setting an initial basis can speed up the solver considerably.
+        /// It is the starting point from where the algorithm continues to find an optimal solution.</para>
+        /// <para>When a restart is done, lp_solve continues at the last basis, except if <see cref="set_basis"/>,
+        /// <see cref="default_basis"/>, <see cref="guess_basis"/> or <see cref="read_basis"/> is called.</para>
+        /// <para>The basis in the file must be in <see href="http://lpsolve.sourceforge.net/5.5/bas-format.htm">MPS bas file format</see>.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/read_basis.htm">Full C API documentation.</seealso>
         public bool read_basis(string filename, string info)
         {
             return Interop.read_basis(_lp, filename, info);
@@ -1893,6 +1890,10 @@
         /// <summary>
         /// Writes current basis to a file.
         /// </summary>
+        /// <param name="filename">Name of file to write the basis to.</param>
+        /// <returns><c>true</c> if basis could be written from <paramref name="filename"/> and <c>false</c> if not.
+        /// A <c>false</c> return value indicates an error.
+        /// Specifically file could not be opened or written to.</returns>
         /// <remarks>
         /// <para>This method writes current basis to a file which can later be reused by <see cref="read_basis"/> to reset the basis.</para>
         /// <para>Setting an initial basis can speed up the solver considerably.
@@ -1902,10 +1903,6 @@
         /// <para>The basis in the file is written in <see href="http://lpsolve.sourceforge.net/5.5/bas-format.htm">MPS bas file format</see>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/write_basis.htm">Full C API documentation.</seealso>
-        /// <param name="filename">Name of file to write the basis to.</param>
-        /// <returns><c>true</c> if basis could be written from <paramref name="filename"/> and <c>false</c> if not.
-        /// A <c>false</c> return value indicates an error.
-        /// Specifically file could not be opened or written to.</returns>
         public bool write_basis(string filename)
         {
             return Interop.write_basis(_lp, filename);
@@ -1914,6 +1911,14 @@
         /// <summary>
         /// Sets an initial basis of the model.
         /// </summary>
+        /// <param name="bascolumn">An array with 1+<see cref="get_Nrows"/> or
+        /// 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/> elements that specifies the basis.</param>
+        /// <param name="nonbasic">If <c>false</c>, then <paramref name="bascolumn"/> must have
+        /// 1+<see cref="get_Nrows"/> elements and only contains the basic variables.
+        /// If <c>true</c>, then <paramref name="bascolumn"/> must have 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/>
+        /// elements and will also contain the non-basic variables.</param>
+        /// <returns><c>true</c> if provided basis was set. <c>false</c> if not.
+        /// If <c>false</c> then provided data was invalid.</returns>
         /// <remarks>
         /// <para>The array receives the basic variables and if <paramref name="nonbasic"/> is <c>true</c>,
         /// then also the non-basic variables.
@@ -1932,22 +1937,21 @@
         /// <see cref="default_basis"/>, <see cref="guess_basis"/> or <see cref="read_basis"/> is called.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_basis.htm">Full C API documentation.</seealso>
+        public bool set_basis(int[] bascolumn, bool nonbasic)
+        {
+            return Interop.set_basis(_lp, bascolumn, nonbasic);
+        }
+
+        /// <summary>
+        /// Returns the basis of the model.
+        /// </summary>
         /// <param name="bascolumn">An array with 1+<see cref="get_Nrows"/> or
-        /// 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/> elements that specifies the basis.</param>
+        /// 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/> elements that will contain the basis after the call.</param>
         /// <param name="nonbasic">If <c>false</c>, then <paramref name="bascolumn"/> must have
         /// 1+<see cref="get_Nrows"/> elements and only contains the basic variables.
         /// If <c>true</c>, then <paramref name="bascolumn"/> must have 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/>
         /// elements and will also contain the non-basic variables.</param>
-        /// <returns><c>true</c> if provided basis was set. <c>false</c> if not.
-        /// If <c>false</c> then provided data was invalid.</returns>
-        public bool set_basis(int[] bascolumn, bool nonbasic)
-        {
-            return Interop.set_basis(_lp, bascolumn, nonbasic);
-        }
-
-        /// <summary>
-        /// Returns the basis of the model.
-        /// </summary>
+        /// <returns><c>true</c> if a basis could be returned, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>This can only be done after a successful solve.
         /// If the model is not successively solved then the function will return <c>false</c>.</para>
@@ -1968,13 +1972,6 @@
         /// <see cref="default_basis"/>, <see cref="guess_basis"/> or <see cref="read_basis"/> is called.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_basis.htm">Full C API documentation.</seealso>
-        /// <param name="bascolumn">An array with 1+<see cref="get_Nrows"/> or
-        /// 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/> elements that will contain the basis after the call.</param>
-        /// <param name="nonbasic">If <c>false</c>, then <paramref name="bascolumn"/> must have
-        /// 1+<see cref="get_Nrows"/> elements and only contains the basic variables.
-        /// If <c>true</c>, then <paramref name="bascolumn"/> must have 1+<see cref="get_Nrows"/>+<see cref="get_Ncolumns"/>
-        /// elements and will also contain the non-basic variables.</param>
-        /// <returns><c>true</c> if a basis could be returned, <c>false</c> otherwise.</returns>
         public bool get_basis(int[] bascolumn, bool nonbasic)
         {
             return Interop.get_basis(_lp, bascolumn, nonbasic);
@@ -1983,13 +1980,6 @@
         /// <summary>
         /// Create a starting base from the provided guess vector.
         /// </summary>
-        /// <remarks>
-        /// <para>This routine is ment to find a basis based on provided variable values.
-        /// This basis can be provided to lp_solve via <see cref="set_basis"/>.
-        /// This can result in getting faster to an optimal solution.
-        /// However the simplex algorithm doesn't guarantee you that.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/guess_basis.htm">Full C API documentation.</seealso>
         /// <param name="guessvector">A vector that must contain a feasible solution vector.
         /// It must contain at least 1+<see cref="get_Ncolumns"/> elements.
         /// Element 0 is not used.</param>
@@ -1998,6 +1988,13 @@
         /// When the routine returns successfully, <paramref name="basisvector"/> is filled with the basis.
         /// This array can be provided to <see cref="set_basis"/>.</param>
         /// <returns><c>true</c> if a valid base could be determined, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// <para>This routine is ment to find a basis based on provided variable values.
+        /// This basis can be provided to lp_solve via <see cref="set_basis"/>.
+        /// This can result in getting faster to an optimal solution.
+        /// However the simplex algorithm doesn't guarantee you that.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/guess_basis.htm">Full C API documentation.</seealso>
         public bool guess_basis(double[] guessvector, int[] basisvector)
         {
             return Interop.guess_basis(_lp, guessvector, basisvector);
@@ -2006,6 +2003,7 @@
         /// <summary>
         /// Returns which basis crash mode must be used.
         /// </summary>
+        /// <returns><c>true</c> if a valid base could be determined, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>Default is <see cref="lpsolve_basiscrash.CRASH_NONE"/></para>
         /// <para>When no base crash is done (the default), the initial basis from which lp_solve
@@ -2018,7 +2016,6 @@
         /// lp_solve starts iterating from this basis until optimality.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_basiscrash.htm">Full C API documentation.</seealso>
-        /// <returns><c>true</c> if a valid base could be determined, <c>false</c> otherwise.</returns>
         public lpsolve_basiscrash get_basiscrash()
         {
             return Interop.get_basiscrash(_lp);
@@ -2027,6 +2024,7 @@
         /// <summary>
         /// Returns which basis crash mode must be used.
         /// </summary>
+        /// <param name="mode">Specifies which basis crash mode must be used.</param>
         /// <remarks>
         /// <para>Default is <see cref="lpsolve_basiscrash.CRASH_NONE"/></para>
         /// <para>When no base crash is done (the default), the initial basis from which lp_solve
@@ -2039,7 +2037,6 @@
         /// lp_solve starts iterating from this basis until optimality.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_basiscrash.htm">Full C API documentation.</seealso>
-        /// <param name="mode">Specifies which basis crash mode must be used.</param>
         public void set_basiscrash(lpsolve_basiscrash mode)
         {
             Interop.set_basiscrash(_lp, mode);
@@ -2048,13 +2045,13 @@
         /// <summary>
         /// Returns if there is a basis factorization package (BFP) available.
         /// </summary>
+        /// <returns><c>true</c> if there is a BFP available, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>There should always be a BFP available, else lpsolve can not solve.
         /// Normally lpsolve is compiled with a default BFP.
         /// See <see href="http://lpsolve.sourceforge.net/5.5/BFP.htm">Basis Factorization Packages</see> for a complete description on BFPs.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/has_BFP.htm">Full C API documentation.</seealso>
-        /// <returns><c>true</c> if there is a BFP available, <c>false</c> otherwise.</returns>
         public bool has_BFP()
         {
             return Interop.has_BFP(_lp);
@@ -2063,12 +2060,12 @@
         /// <summary>
         /// Returns if the native (build-in) basis factorization package (BFP) is used, or an external package.
         /// </summary>
+        /// <returns><c>true</c> if the native (build-in) BFP is used, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>This method checks if an external basis factorization package (BFP) is set or not.
         /// See <see href="http://lpsolve.sourceforge.net/5.5/BFP.htm">Basis Factorization Packages</see> for a complete description on BFPs.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_nativeBFP.htm">Full C API documentation.</seealso>
-        /// <returns><c>true</c> if the native (build-in) BFP is used, <c>false</c> otherwise.</returns>
         public bool is_nativeBFP()
         {
             return Interop.is_nativeBFP(_lp);
@@ -2077,11 +2074,6 @@
         /// <summary>
         /// Sets the basis factorization package.
         /// </summary>
-        /// <remarks>
-        /// <para>This method sets the basis factorization package (BFP).
-        /// See <see href="http://lpsolve.sourceforge.net/5.5/BFP.htm">Basis Factorization Packages</see> for a complete description on BFPs.</para>
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_BFP.htm">Full C API documentation.</seealso>
         /// <param name="filename">The name of the BFP package. Currently following BFPs are implemented:
         /// <list type="table">
         /// <item>
@@ -2094,23 +2086,28 @@
         /// However the user can also build his own BFP packages ...
         /// </param>
         /// <returns><c>true</c> if the call succeeded, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// <para>This method sets the basis factorization package (BFP).
+        /// See <see href="http://lpsolve.sourceforge.net/5.5/BFP.htm">Basis Factorization Packages</see> for a complete description on BFPs.</para>
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_BFP.htm">Full C API documentation.</seealso>
         public bool set_BFP(string filename)
         {
             return Interop.set_BFP(_lp, filename);
         }

-#endregion
-
-#region Pivoting
+        #endregion
+
+        #region Pivoting

         /// <summary>
         /// Returns the maximum number of pivots between a re-inversion of the matrix.
         /// </summary>
+        /// <returns>Returns the maximum number of pivots between a re-inversion of the matrix.</returns>
         /// <remarks>
         /// <para>For stability reasons, lp_solve re-inverts the matrix on regular times. max_num_inv determines how frequently this inversion is done. This can influence numerical stability. However, the more often this is done, the slower the solver becomes.</para>
         /// <para>The default is 250 for the LUSOL bfp and 42 for the other BFPs.</para></remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_maxpivot.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the maximum number of pivots between a re-inversion of the matrix.</returns>
         public int get_maxpivot()
         {
             return Interop.get_maxpivot(_lp);
@@ -2119,11 +2116,11 @@
         /// <summary>
         /// Sets the maximum number of pivots between a re-inversion of the matrix.
         /// </summary>
+        /// <param name="max_num_inv">The maximum number of pivots between a re-inversion of the matrix.</param>
         /// <remarks>
         /// <para>For stability reasons, lp_solve re-inverts the matrix on regular times. max_num_inv determines how frequently this inversion is done. This can influence numerical stability. However, the more often this is done, the slower the solver becomes.</para>
         /// <para>The default is 250 for the LUSOL bfp and 42 for the other BFPs.</para></remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_maxpivot.htm">Full C API documentation.</seealso>
-        /// <param name="max_num_inv">The maximum number of pivots between a re-inversion of the matrix.</param>
         public void set_maxpivot(int max_num_inv)
         {
             Interop.set_maxpivot(_lp, max_num_inv);
@@ -2132,6 +2129,7 @@
         /// <summary>
         /// Returns the pivot rule and modes. See <see cref="lpsolve_pivot_rule"/> and <see cref="lpsolve_pivot_modes"/> for possible values.
         /// </summary>
+        /// <returns>The pivot rule (rule for selecting row and column entering/leaving) and mode.</returns>
         /// <remarks>
         /// <para>The rule is an exclusive option and the mode is a modifier to the rule.
         /// This rule/mode can influence solving times considerably.
@@ -2139,7 +2137,6 @@
         /// <para>The default rule is <see cref="lpsolve_pivot_rule.PRICER_DEVEX"/> and the default mode is <see cref="lpsolve_pivot_modes.PRICE_ADAPTIVE"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_pivoting.htm">Full C API documentation.</seealso>
-        /// <returns>The pivot rule (rule for selecting row and column entering/leaving) and mode.</returns>
         public PivotRuleAndModes get_pivoting()
         {
             int pivoting = Interop.get_pivoting(_lp);
@@ -2155,6 +2152,8 @@
         /// <summary>
         /// Sets the pivot rule and modes.
         /// </summary>
+        /// <param name="rule">The pivot <see cref="lpsolve_pivot_rule">rule</see> (rule for selecting row and column entering/leaving).</param>
+        /// <param name="modes">The <see cref="lpsolve_pivot_modes">modes</see> modifying the <see cref="lpsolve_pivot_rule">rule</see>.</param>
         /// <remarks>
         /// <para>The rule is an exclusive option and the mode is a modifier to the rule.
         /// This rule/mode can influence solving times considerably.
@@ -2162,8 +2161,6 @@
         /// <para>The default rule is <see cref="lpsolve_pivot_rule.PRICER_DEVEX"/> and the default mode is <see cref="lpsolve_pivot_modes.PRICE_ADAPTIVE"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_pivoting.htm">Full C API documentation.</seealso>
-        /// <param name="rule">The pivot <see cref="lpsolve_pivot_rule">rule</see> (rule for selecting row and column entering/leaving).</param>
-        /// <param name="modes">The <see cref="lpsolve_pivot_modes">modes</see> modifying the <see cref="lpsolve_pivot_rule">rule</see>.</param>
         public void set_pivoting(lpsolve_pivot_rule rule, lpsolve_pivot_modes modes)
         {
             Interop.set_pivoting(_lp, ((int)rule)| ((int)modes));
@@ -2172,6 +2169,8 @@
         /// <summary>
         /// Checks if the specified pivot rule is active.
         /// </summary>
+        /// <param name="rule">Rule to check.</param>
+        /// <returns><c>true</c> if the specified pivot rule is active, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>
         /// This rule/mode can influence solving times considerably.
@@ -2179,8 +2178,6 @@
         /// <para>The default is <see cref="lpsolve_pivot_rule.PRICER_DEVEX"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_piv_rule.htm">Full C API documentation.</seealso>
-        /// <param name="rule">Rule to check.</param>
-        /// <returns><c>true</c> if the specified pivot rule is active, <c>false</c> otherwise.</returns>
         public bool is_piv_rule(lpsolve_pivot_rule rule)
         {
             return Interop.is_piv_rule(_lp, rule);
@@ -2190,26 +2187,27 @@
         /// <summary>
         /// Checks if the pivot mode specified in <paramref name="testmask"/> is active.
         /// </summary>
-        /// <remarks>
-        /// The pivot mode is an extra modifier to the pivot rule. Any combination (OR) of the defined values is possible.
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_piv_mode.htm">Full C API documentation.</seealso>
         /// <param name="testmask">Any combination of <see cref="lpsolve_pivot_modes"/> to check if they are active.</param>
         /// <returns><c>true</c> if all the specified modes are active, <c>false</c> otherwise.</returns>
+        /// <remarks>
+        /// The pivot mode is an extra modifier to the pivot rule. Any combination (OR) of the defined values is possible.
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_piv_mode.htm">Full C API documentation.</seealso>
         public bool is_piv_mode(lpsolve_pivot_modes testmask)
         {
             return Interop.is_piv_mode(_lp, testmask);
         }

-#endregion
-
-#region Scaling
+        #endregion
+
+        #region Scaling
+
         /// <summary>
         /// Gets the relative scaling convergence criterion for the active scaling mode.
         /// </summary>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_scalelimit.htm">Full C API documentation.</seealso>
         /// <returns>The relative scaling convergence criterion for the active scaling mode;
         /// the integer part specifies the maximum number of iterations.</returns>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_scalelimit.htm">Full C API documentation.</seealso>
         public double get_scalelimit()
         {
             return Interop.get_scalelimit(_lp);
@@ -2219,12 +2217,12 @@
         /// Sets the relative scaling convergence criterion for the active scaling mode;
         /// the integer part specifies the maximum number of iterations.
         /// </summary>
-        /// <remarks>
-        /// Default is 5.
-        /// </remarks>
-        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_scalelimit.htm">Full C API documentation.</seealso>
         /// <param name="scalelimit">The relative scaling convergence criterion for the active scaling mode;
         /// the integer part specifies the maximum number of iterations.</param>
+        /// <remarks>
+        /// Default is 5.
+        /// </remarks>
+        /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_scalelimit.htm">Full C API documentation.</seealso>
         public void set_scalelimit(double scalelimit)
         {
             Interop.set_scalelimit(_lp, scalelimit);
@@ -2233,6 +2231,7 @@
         /// <summary>
         /// Specifies which scaling algorithm and parameters are used.
         /// </summary>
+        /// <returns>The scaling algorithm and parameters that are used.</returns>
         /// <remarks>
         /// <para>
         /// This can influence numerical stability considerably.
@@ -2241,7 +2240,6 @@
         /// See <see cref="ScalingAlgorithmAndParameters" /> for more information on scaling.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_scaling.htm">Full C API documentation.</seealso>
-        /// <returns>The scaling algorithm and parameters that are used.</returns>
         public ScalingAlgorithmAndParameters get_scaling()
         {
             int scaling = Interop.get_scaling(_lp);
@@ -2257,6 +2255,8 @@
         /// <summary>
         /// Specifies which scaling algorithm and parameters must be used.
         /// </summary>
+        /// <param name="algorithm">Specifies which scaling algorithm must be used.</param>
+        /// <param name="parameters">Specifies which parameters to apply to scaling <paramref name="algorithm"/>.</param>
         /// <remarks>
         /// <para>
         /// This can influence numerical stability considerably.
@@ -2265,8 +2265,6 @@
         /// See <see cref="ScalingAlgorithmAndParameters" /> for more information on scaling.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_scaling.htm">Full C API documentation.</seealso>
-        /// <param name="algorithm">Specifies which scaling algorithm must be used.</param>
-        /// <param name="parameters">Specifies which parameters to apply to scaling <paramref name="algorithm"/>.</param>
         public void set_scaling(lpsolve_scale_algorithm algorithm, lpsolve_scale_parameters parameters)
         {
             Interop.set_scaling(_lp, ((int)algorithm)|((int)parameters));
@@ -2275,12 +2273,15 @@
         /// <summary>
         /// Returns if scaling algorithm and parameters specified are active.
         /// </summary>
+        /// <param name="algorithmMask">Specifies which scaling algorithm to verify.
+        /// Optional with default = <see cref="lpsolve_scale_algorithm.SCALE_NONE"/></param>
+        /// <param name="parameterMask">Specifies which parameters must be verified.
+        /// Optional with default = <see cref="lpsolve_scale_parameters.SCALE_NONE"/></param>
+        /// <returns><c>true</c> if scaling algorithm and parameters specified are active, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// See <see cref="ScalingAlgorithmAndParameters" /> for more information on scaling.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_scaling.htm">Full C API documentation.</seealso>
-        /// <param name="algorithmMask">Specifies which scaling algorithm to verify.</param>
-        /// <param name="parameterMask">Specifies which parameters must be verified.</param>
         public bool is_scalemode(
             lpsolve_scale_algorithm algorithmMask = lpsolve_scale_algorithm.SCALE_NONE,
             lpsolve_scale_parameters parameterMask = lpsolve_scale_parameters.SCALE_NONE)
@@ -2291,11 +2292,12 @@
         /// <summary>
         /// Returns if scaling algorithm specified is active.
         /// </summary>
+        /// <param name="algorithm">Specifies which scaling algorithm to verify.</param>
+        /// <returns><c>true</c> if scaling algorithm specified is active, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// See <see cref="ScalingAlgorithmAndParameters" /> for more information on scaling.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_scaling.htm">Full C API documentation.</seealso>
-        /// <param name="algorithm">Specifies which scaling algorithm to verify.</param>
         public bool is_scaletype(lpsolve_scale_algorithm algorithm)
         {
             return Interop.is_scaletype(_lp, algorithm);
@@ -2304,12 +2306,12 @@
         /// <summary>
         /// Returns if integer scaling is active.
         /// </summary>
+        /// <returns><c>true</c> if <see cref="lpsolve_scale_parameters.SCALE_INTEGERS"/> was set with <see cref="set_scaling"/>.</returns>
         /// <remarks>
         /// By default, integers are not scaled, you mus call <see cref="set_scaling"/>
         /// with <see cref="lpsolve_scale_parameters.SCALE_INTEGERS"/> to activate this feature.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_integerscaling.htm">Full C API documentation.</seealso>
-        /// <returns><c>true</c> if <see cref="lpsolve_scale_parameters.SCALE_INTEGERS"/> was set with <see cref="set_scaling"/>.</returns>
         public bool is_integerscaling()
         {
             return Interop.is_integerscaling(_lp);
@@ -2329,13 +2331,17 @@
             Interop.unscale(_lp);
         }

-#endregion
-
-#region Branching
+        #endregion
+
+        #region Branching

         /// <summary>
         /// Returns, for the specified variable, which branch to take first in branch-and-bound algorithm.
         /// </summary>
+        /// <param name="column">The column number of the variable on which the mode must be returned.
+        /// It must be between 1 and the number of columns in the model.
+        /// If it is not within this range, the return value is the value of <see cref="get_bb_floorfirst"/>.</param>
+        /// <returns>Returns which branch to take first in branch-and-bound algorithm.</returns>
         /// <remarks>
         /// This method returns which branch to take first in branch-and-bound algorithm.
         /// This can influence solving times considerably.
@@ -2344,10 +2350,6 @@
         /// It also returns the value of <see cref="get_bb_floorfirst"/> when <see cref="set_var_branch"/> was called with branch mode <see cref="lpsolve_branch.BRANCH_DEFAULT">BRANCH_DEFAULT (3)</see>.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_var_branch.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable on which the mode must be returned.
-        /// It must be between 1 and the number of columns in the model.
-        /// If it is not within this range, the return value is the value of <see cref="get_bb_floorfirst"/>.</param>
-        /// <returns>Returns which branch to take first in branch-and-bound algorithm.</returns>
         public lpsolve_branch get_var_branch(int column)
         {
             return Interop.get_var_branch(_lp, column);
@@ -2356,6 +2358,10 @@
         /// <summary>
         /// Specifies, for the specified variable, which branch to take first in branch-and-bound algorithm.
         /// </summary>
+        /// <param name="column">The column number of the variable on which the mode must be set.
+        /// It must be between 1 and the number of columns in the model.</param>
+        /// <param name="branch_mode">Specifies, for the specified variable, which branch to take first in branch-and-bound algorithm.</param>
+        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>
         /// This method specifies which branch to take first in branch-and-bound algorithm.
@@ -2366,10 +2372,6 @@
         /// the branch mode specified with <see cref="set_bb_floorfirst"/> function must be used.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_var_branch.htm">Full C API documentation.</seealso>
-        /// <param name="column">The column number of the variable on which the mode must be set.
-        /// It must be between 1 and the number of columns in the model.</param>
-        /// <param name="branch_mode">Specifies, for the specified variable, which branch to take first in branch-and-bound algorithm.</param>
-        /// <returns><c>true</c> if successful, <c>false</c> otherwise.</returns>
         public bool set_var_branch(int column, lpsolve_branch branch_mode)
         {
             return Interop.set_var_branch(_lp, column, branch_mode);
@@ -2378,13 +2380,13 @@
         /// <summary>
         /// Returns whether the branch-and-bound algorithm stops at first found solution or not.
         /// </summary>
+        /// <returns><c>true</c> if the branch-and-bound algorithm stops at first found solution, <c>false</c> otherwise.</returns>
         /// <remarks>
         /// <para>The method returns if the branch-and-bound algorithm stops at the first found solution or not.
         /// Stopping at the first found solution can be useful if you are only interested for a solution,
         /// but not necessarily (and most probably) the most optimal solution.</para>
         /// <para>The default is <c>false</c>: not stop at first found solution.</para></remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/is_break_at_first.htm">Full C API documentation.</seealso>
-        /// <returns><c>true</c> if the branch-and-bound algorithm stops at first found solution, <c>false</c> otherwise.</returns>
         public bool is_break_at_first()
         {
             return Interop.is_break_at_first(_lp);
@@ -2393,6 +2395,7 @@
         /// <summary>
         /// Specifies whether the branch-and-bound algorithm stops at first found solution or not.
         /// </summary>
+        /// <param name="break_at_first"><c>true</c> if the branch-and-bound algorithm should break at first found solution, <c>false</c> if not.</param>
         /// <remarks>
         /// <para>The method specifies if the branch-and-bound algorithm stops at the first found solution or not.
         /// Stopping at the first found solution can be useful if you are only interested for a solution,
@@ -2407,6 +2410,7 @@
         /// <summary>
         /// Returns the value which would cause the branch-and-bound algorithm to stop when the objective value reaches it.
         /// </summary>
+        /// <returns>Returns the value to break on.</returns>
         /// <remarks>
         /// <para>The method returns the value at which the branch-and-bound algorithm stops when the objective value
         /// is better than this value. Stopping at a given objective value can be useful if you are only interested
@@ -2414,7 +2418,6 @@
         /// (and most probably not) the most optimal solution.</para>
         /// <para>The default value is (-) infinity (or +infinity when maximizing).</para></remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_break_at_value.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the value to break on.</returns>
         public double get_break_at_value()
         {
             return Interop.get_break_at_value(_lp);
@@ -2423,6 +2426,7 @@
         /// <summary>
         /// Specifies the value which would cause the branch-and-bound algorithm to stop when the objective value reaches it.
         /// </summary>
+        /// <param name="break_at_value">The value to break on.</param>
         /// <remarks>
         /// <para>The method sets the value at which the branch-and-bound algorithm stops when the objective value
         /// is better than this value. Stopping at a given objective value can be useful if you are only interested
@@ -2438,6 +2442,7 @@
         /// <summary>
         /// Returns the branch-and-bound rule.
         /// </summary>
+        /// <returns>Returns the <see cref="lpsolve_BBstrategies">branch-and-bound rule</see>.</returns>
         /// <remarks>
         /// <para>The method returns the branch-and-bound rule for choosing which non-integer variable is to be selected.
         /// This rule can influence solving times considerably.
@@ -2445,7 +2450,6 @@
         /// <para>The default is NODE_PSEUDONONINTSELECT + NODE_GREEDYMODE + NODE_DYNAMICMODE + NODE_RCOSTFIXING(17445).</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_bb_rule.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the <see cref="lpsolve_BBstrategies">branch-and-bound rule</see>.</returns>
         public lpsolve_BBstrategies get_bb_rule()
         {
             return Interop.get_bb_rule(_lp);
@@ -2454,6 +2458,7 @@
         /// <summary>
         /// Specifies the branch-and-bound rule.
         /// </summary>
+        /// <param name="bb_rule">The <see cref="lpsolve_BBstrategies">branch-and-bound rule</see> to set.</param>
         /// <remarks>
         /// <para>The method specifies the branch-and-bound rule for choosing which non-integer variable is to be selected.
         /// This rule can influence solving times considerably.
@@ -2461,7 +2466,6 @@
         /// <para>The default is NODE_PSEUDONONINTSELECT + NODE_GREEDYMODE + NODE_DYNAMICMODE + NODE_RCOSTFIXING(17445).</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_bb_rule.htm">Full C API documentation.</seealso>
-        /// <param name="bb_rule">The <see cref="lpsolve_BBstrategies">branch-and-bound rule</see> to set.</param>
         public void set_bb_rule(lpsolve_BBstrategies bb_rule)
         {
             Interop.set_bb_rule(_lp, bb_rule);
@@ -2470,6 +2474,7 @@
         /// <summary>
         /// Returns the maximum branch-and-bound depth.
         /// </summary>
+        /// <returns>Returns the maximum branch-and-bound depth</returns>
         /// <remarks>
         /// <para>The method returns the maximum branch-and-bound depth.</para>
         /// <para>This is only useful if there are integer, semi-continuous or SOS variables in the model so that the
@@ -2485,7 +2490,6 @@
         /// <para>The default is -50.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_bb_depthlimit.htm">Full C API documentation.</seealso>
-        /// <returns>Returns the maximum branch-and-bound depth</returns>
         public int get_bb_depthlimit()
         {
             return Interop.get_bb_depthlimit(_lp);
@@ -2494,6 +2498,11 @@
         /// <summary>
         /// Sets the maximum branch-and-bound depth.
         /// </summary>
+        /// <param name="bb_maxlevel">Specifies the maximum branch-and-bound depth.
+        /// A positive value means that the depth is absoluut.
+        /// A negative value means a relative B&B depth limit.
+        /// The "order" of a MIP problem is defined to be 2x the number of binary variables plus the number of SC and SOS variables.
+        /// A relative value of -x results in a maximum depth of x times the order of the MIP problem.</param>
         /// <remarks>
         /// <para>The method specifies the maximum branch-and-bound depth.</para>
         /// <para>This is only useful if there are integer, semi-continuous or SOS variables in the model so that the
@@ -2505,11 +2514,6 @@
         /// <para>The default is -50.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_bb_depthlimit.htm">Full C API documentation.</seealso>
-        /// <param name="bb_maxlevel">Specifies the maximum branch-and-bound depth.
-        /// A positive value means that the depth is absoluut.
-        /// A negative value means a relative B&B depth limit.
-        /// The "order" of a MIP problem is defined to be 2x the number of binary variables plus the number of SC and SOS variables.
-        /// A relative value of -x results in a maximum depth of x times the order of the MIP problem.</param>
         public void set_bb_depthlimit(int bb_maxlevel)
         {
             Interop.set_bb_depthlimit(_lp, bb_maxlevel);
@@ -2518,6 +2522,7 @@
         /// <summary>
         /// Returns which branch to take first in branch-and-bound algorithm.
         /// </summary>
+        /// <returns>Returns which branch to take first in branch-and-bound algorithm.</returns>
         /// <remarks>
         /// <para>The method returns which branch to take first in branch-and-bound algorithm.
         /// This can influence solving times considerably.
@@ -2525,7 +2530,6 @@
         /// <para>The default is <see cref="lpsolve_branch.BRANCH_AUTOMATIC"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_bb_floorfirst.htm">Full C API documentation.</seealso>
-        /// <returns>Returns which branch to take first in branch-and-bound algorithm.</returns>
         public lpsolve_branch get_bb_floorfirst()
         {
             return Interop.get_bb_floorfirst(_lp);
@@ -2534,6 +2538,7 @@
         /// <summary>
         /// Specifies which branch to take first in branch-and-bound algorithm.
         /// </summary>
+        /// <param name="bb_floorfirst">Specifies which branch to take first in branch-and-bound algorithm.</param>
         /// <remarks>
         /// <para>The method specifies which branch to take first in branch-and-bound algorithm.
         /// This can influence solving times considerably.
@@ -2541,22 +2546,21 @@
         /// <para>The default is <see cref="lpsolve_branch.BRANCH_AUTOMATIC"/>.</para>
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_bb_floorfirst.htm">Full C API documentation.</seealso>
-        /// <param name="bb_floorfirst">Specifies which branch to take first in branch-and-bound algorithm.</param>
         public void set_bb_floorfirst(lpsolve_branch bb_floorfirst)
         {
             Interop.set_bb_floorfirst(_lp, bb_floorfirst);
         }

-#endregion
+        #endregion

         /// <summary>
         /// Returns the iterative improvement level.
         /// </summary>
+        /// <returns>The iterative improvement level</returns>
         /// <remarks>
         /// The default is <see cref="lpsolve_improves.IMPROVE_DUALFEAS"/> + <see cref="lpsolve_improves.IMPROVE_THETAGAP"/>.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/get_improve.htm">Full C API documentation.</seealso>
-        /// <returns>The iterative improvement level</returns>
         public lpsolve_improves get_improve()
         {
             return Interop.get_improve(_lp);
@@ -2565,17 +2569,16 @@
         /// <summary>
         /// Specifies the iterative improvement level.
         /// </summary>
+        /// <param name="improve">The iterative improvement level.</param>
         /// <remarks>
         /// The default is <see cref="lpsolve_improves.IMPROVE_DUALFEAS"/> + <see cref="lpsolve_improves.IMPROVE_THETAGAP"/>.
         /// </remarks>
         /// <seealso href="http://lpsolve.sourceforge.net/5.5/set_improve.htm">Full C API documentation.</seealso>
-        /// <param name="improve">The iterative improvement level.</param>
         public void set_improve(lpsolve_improves improve)
         {
             Interop.set_improve(_lp, improve);
         }

-        //TODO: above need to move documentation tag order
         /// <summary>
         /// Returns the negative value below which variables are split into a negative and a positive part.
         /// </summary>
@@ -2850,7 +2853,7 @@
         {
             Interop.set_preferdual(_lp, dodual);
         }
-
+//TODO: documentation tag order and completeness completed above, need to do below. Also need to do everywhere: verify seealso, function=>method, ...
         public int get_solutionlimit()
         {
             return Interop.get_solutionlimit(_lp);
@@ -2901,9 +2904,9 @@
             Interop.set_presolve(_lp, do_presolve, maxloops);
         }

-#endregion
-
-#region Callback routines
+        #endregion
+
+        #region Callback routines

         public void put_abortfunc(ctrlcfunc newctrlc, IntPtr ctrlchandle)
         {
@@ -2920,18 +2923,18 @@
             Interop.put_msgfunc(_lp, newmsg, msghandle, mask);
         }

-#endregion
-
-#region Solve
+        #endregion
+
+        #region Solve

         public lpsolve_return solve()
         {
             return Interop.solve(_lp);
         }

-#endregion
-
-#region Solution
+        #endregion
+
+        #region Solution

         public double get_constr_value(int row, int count, double[] primsolution, int[] nzindex)
         {
@@ -3019,9 +3022,9 @@
             return Interop.is_feasible(_lp, values, threshold);
         }

-#endregion
-
-#region Debug/print settings
+        #endregion
+
+        #region Debug/print settings

         public bool set_outputfile(string filename)
         {
@@ -3068,9 +3071,9 @@
             Interop.set_trace(_lp, trace);
         }

-#endregion
-
-#region Debug/print
+        #endregion
+
+        #region Debug/print

         public void print_constraints(int columns)
         {
@@ -3117,9 +3120,9 @@
             Interop.print_tableau(_lp);
         }

-#endregion
-
-#region Write model to file
+        #endregion
+
+        #region Write model to file

         public bool write_lp(string filename)
         {
@@ -3156,9 +3159,9 @@
             return Interop.write_XLI(_lp, filename, options, results);
         }

-#endregion
-
-#region Miscellaneous routines
+        #endregion
+
+        #region Miscellaneous routines

         /// <summary>
         /// Returns the version of the lpsolve library loaded ar runtime.