Added header files for Ipopt 3.12.7,minor modifications to symphony's output texts

40 files changed, 4542 insertions, 371 deletions

diff --git a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
index ff447af..5a05bab 100755
--- a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
+++ b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
diff --git a/sci_gateway/cpp/sci_ipoptfmincon.cpp b/sci_gateway/cpp/sci_ipoptfmincon.cpp
index 51f1cce..803d4f3 100644
--- a/sci_gateway/cpp/sci_ipoptfmincon.cpp
+++ b/sci_gateway/cpp/sci_ipoptfmincon.cpp
@@ -127,6 +127,7 @@ int sci_solveminconp(char *fname)
 	nVars = x0_cols;
 	nCons = A_rows + Aeq_rows + nonlinCon;
 
+
         
         // Starting Ipopt
 
@@ -138,7 +139,7 @@ int sci_solveminconp(char *fname)
 	app->Options()->SetNumericValue("tol", 1e-6);
 	app->Options()->SetIntegerValue("max_iter", (int)*max_iter);
 	app->Options()->SetNumericValue("max_cpu_time", *cpu_time);
-//	app->Options()->SetStringValue("hessian_approximation", "limited-memory");
+	app->Options()->SetStringValue("hessian_approximation", "limited-memory");
 
 	///////// Initialize the IpoptApplication and process the options /////////
 	ApplicationReturnStatus status;
@@ -148,7 +149,7 @@ int sci_solveminconp(char *fname)
 	  	sciprint("\n*** Error during initialization!\n");
    		return (int) status;
  	 }
-	 
+
 	 // Ask Ipopt to solve the problem
 	 status = app->OptimizeTNLP((SmartPtr<TNLP>&)Prob);
 	 //Get the solve statistics
@@ -157,7 +158,7 @@ int sci_solveminconp(char *fname)
 	 app->Statistics()->Infeasibilities(dual_inf, constr_viol, complementarity, kkt_error);
 	 rstatus = Prob->returnStatus();
 	 fobj_eval=(double)int_fobj_eval;
-         
+
 	////////// Manage the output argument //////////
 
 	fX = Prob->getX();
diff --git a/sci_gateway/cpp/sci_minconNLP.cpp b/sci_gateway/cpp/sci_minconNLP.cpp
index ab15392..e800221 100644
--- a/sci_gateway/cpp/sci_minconNLP.cpp
+++ b/sci_gateway/cpp/sci_minconNLP.cpp
@@ -23,23 +23,23 @@ extern "C"
 #include <string.h>
 #include <assert.h>
 
-using namespace std;
-using namespace Ipopt;
+	using namespace std;
+	using namespace Ipopt;
 
-minconNLP::~minconNLP()
-{
-	if(finalX_) delete[] finalX_;
-	if(finalZl_) delete[] finalZl_;
-	if(finalZu_) delete[] finalZu_;
-	if(finalLambda_) delete[] finalLambda_;
-}
+	minconNLP::~minconNLP()
+	{
+		if(finalX_) delete[] finalX_;
+		if(finalZl_) delete[] finalZl_;
+		if(finalZu_) delete[] finalZu_;
+		if(finalLambda_) delete[] finalLambda_;
+	}
 
 //get NLP info such as number of variables,constraints,no.of elements in jacobian and hessian to allocate memory
-bool minconNLP::get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style)
-{
-	finalGradient_ = (double*)malloc(sizeof(double) * numVars_ * 1);
-	finalHessian_ = (double*)malloc(sizeof(double) * numVars_ * numVars_);
-	
+	bool minconNLP::get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, IndexStyleEnum& index_style)
+	{
+		finalGradient_ = (double*)malloc(sizeof(double) * numVars_ * 1);
+		finalHessian_ = (double*)malloc(sizeof(double) * numVars_ * numVars_);
+		
 	n=numVars_; // Number of variables
 	m=numConstr_; // Number of constraints
 
@@ -63,9 +63,9 @@ bool minconNLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Numb
 	}
 	
 	if(m==0)
-        {
+	{
 		g_l=NULL;
-	        g_u=NULL;
+		g_u=NULL;
 	}
 
 	else
@@ -79,7 +79,7 @@ bool minconNLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Numb
 			g_u[c]=0;
 			c++;
 		}
-	
+		
 		//bounds of non-linear equality constraints
 		for(i=0;i<nonlinCon_-nonlinIneqCon_;i++)
 		{
@@ -111,9 +111,9 @@ bool minconNLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Numb
 // This method sets initial values for required vectors . For now we are assuming 0 to all values. 
 bool minconNLP::get_starting_point(Index n, bool init_x, Number* x,bool init_z, Number* z_L, Number* z_U,Index m, bool init_lambda,Number* lambda)
 {	
- 	assert(init_x == true);
-  	assert(init_z == false);
-  	assert(init_lambda == false);
+	assert(init_x == true);
+	assert(init_z == false);
+	assert(init_lambda == false);
 	if (init_x == true)
 	{ //we need to set initial values for vector x
 		for (Index var=0;var<n;var++)
@@ -126,27 +126,27 @@ bool minconNLP::get_starting_point(Index n, bool init_x, Number* x,bool init_z,
 //get value of objective function at vector x
 bool minconNLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value)
 {	
-  	int* funptr=NULL;  
-  	if(getFunctionFromScilab(1,&funptr))
-  	{
+	int* funptr=NULL;  
+	if(getFunctionFromScilab(1,&funptr))
+	{
 		return 1;
- 	}
-  	char name[18]="f";
-  	double obj=0;
-  	const Number *xNew=x;
-  	double check;
-  	createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
-  	int positionFirstElementOnStackForScilabFunction = 14;
-  	int numberOfRhsOnScilabFunction = 1;
-  	int numberOfLhsOnScilabFunction = 2;
-  	int pointerOnScilabFunction     = *funptr;
-   
-  	C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
-                                                               &numberOfLhsOnScilabFunction,
-                                                               &numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
-                              
-  	if(getDoubleFromScilab(15,&check))
-  	{
+	}
+	char name[18]="f";
+	double obj=0;
+	const Number *xNew=x;
+	double check;
+	createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
+	int positionFirstElementOnStackForScilabFunction = 14;
+	int numberOfRhsOnScilabFunction = 1;
+	int numberOfLhsOnScilabFunction = 2;
+	int pointerOnScilabFunction     = *funptr;
+	
+	C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
+		&numberOfLhsOnScilabFunction,
+		&numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
+	
+	if(getDoubleFromScilab(15,&check))
+	{
 		return true;
 	}
 	if (check==1)
@@ -156,44 +156,44 @@ bool minconNLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value)
 	}	
 	else
 	{    
-  		if(getDoubleFromScilab(14,&obj))
-  		{
+		if(getDoubleFromScilab(14,&obj))
+		{
 			sciprint("No obj value");
 			return 1;
-  		}
-  		obj_value=obj;  
-	
-  		return true;
+		}
+		obj_value=obj;  
+		
+		return true;
 	}
 }
 
 //get value of gradient of objective function at vector x.
 bool minconNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f)
 {
-  	
+	
 
-  		int* gradptr=NULL;
-  		if(getFunctionFromScilab(11,&gradptr))
-  		{
-			return 1;
-  		}  
-  		const Number *xNew=x;
-	  	createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
-  		int positionFirstElementOnStackForScilabFunction = 14;
-  		int numberOfRhsOnScilabFunction = 1;
-  		int numberOfLhsOnScilabFunction = 2;
-  		int pointerOnScilabFunction     = *gradptr;
-		char name[18]="fGrad1";
- 
-  		C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
-        	                                                       &numberOfLhsOnScilabFunction,
-        	                                                       &numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
+	int* gradptr=NULL;
+	if(getFunctionFromScilab(11,&gradptr))
+	{
+		return 1;
+	}  
+	const Number *xNew=x;
+	createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
+	int positionFirstElementOnStackForScilabFunction = 14;
+	int numberOfRhsOnScilabFunction = 1;
+	int numberOfLhsOnScilabFunction = 2;
+	int pointerOnScilabFunction     = *gradptr;
+	char name[18]="fGrad1";
+	
+	C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
+		&numberOfLhsOnScilabFunction,
+		&numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
 
 	double* resg;
 	double check;
-  	int x0_rows,x0_cols;                           
-   	if(getDoubleFromScilab(15,&check))
-  	{
+	int x0_rows,x0_cols;                           
+	if(getDoubleFromScilab(15,&check))
+	{
 		return true;
 	}
 	if (check==1)
@@ -202,21 +202,21 @@ bool minconNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f
 	}	
 	else
 	{ 	
-  	 	if(getDoubleMatrixFromScilab(14, &x0_rows, &x0_cols, &resg))
-  		{
+		if(getDoubleMatrixFromScilab(14, &x0_rows, &x0_cols, &resg))
+		{
 			sciprint("No results");
 			return 1;
 		}
 
 
-  		Index i;
-  		for(i=0;i<numVars_;i++)
-  		{
+		Index i;
+		for(i=0;i<numVars_;i++)
+		{
 			grad_f[i]=resg[i];
-        	finalGradient_[i]=resg[i];
-  		}
+			finalGradient_[i]=resg[i];
+		}
 	}		
-  		return true;
+	return true;
 }
 
 // return the value of the constraints: g(x)
@@ -227,7 +227,7 @@ bool minconNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)
 	unsigned int j;
 
 	if(m==0)
-  		g=NULL;
+		g=NULL;
 
 	else
 	{
@@ -237,28 +237,28 @@ bool minconNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)
 		if(nonlinCon_!=0)
 		{
 			int* constr=NULL;  
-	  		if(getFunctionFromScilab(10,&constr))
-	  		{
+			if(getFunctionFromScilab(10,&constr))
+			{
 				return 1;
-	 		}
-	  		
-		  	const Number *xNew=x;
-		  	double check;
-  			createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
-  			int positionFirstElementOnStackForScilabFunction = 14;
-  			int numberOfRhsOnScilabFunction = 1;
-  			int numberOfLhsOnScilabFunction = 2;
-  			int pointerOnScilabFunction     = *constr;
-  			char name[18]="addnlc1";
-  			
- 		 	C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
-                                                               &numberOfLhsOnScilabFunction,
-                                                               &numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
+			}
+			
+			const Number *xNew=x;
+			double check;
+			createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
+			int positionFirstElementOnStackForScilabFunction = 14;
+			int numberOfRhsOnScilabFunction = 1;
+			int numberOfLhsOnScilabFunction = 2;
+			int pointerOnScilabFunction     = *constr;
+			char name[18]="addnlc1";
+			
+			C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
+				&numberOfLhsOnScilabFunction,
+				&numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
 
 			double* resc;  
-		  	int xC_rows,xC_cols;                           
-		  	if(getDoubleFromScilab(15,&check))
-  			{
+			int xC_rows,xC_cols;                           
+			if(getDoubleFromScilab(15,&check))
+			{
 				return true;
 			}
 			if (check==1)
@@ -267,12 +267,12 @@ bool minconNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)
 			}	
 			else
 			{        
-		  		if(getDoubleMatrixFromScilab(14, &xC_rows, &xC_cols, &resc))
-		  		{
+				if(getDoubleMatrixFromScilab(14, &xC_rows, &xC_cols, &resc))
+				{
 					sciprint("No results");
 					return 1;
-		
-		  		}
+					
+				}
 
 				for(i=0;i<nonlinCon_;i++)
 				{
@@ -302,115 +302,115 @@ bool minconNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)
 
 	}
 
-  	return true;
+	return true;
 }
 
 // return the structure or values of the jacobian
 bool minconNLP::eval_jac_g(Index n, const Number* x, bool new_x,Index m, Index nele_jac, Index* iRow, Index *jCol,Number* values)
 {	
- 	if (values == NULL) 
- 	{
+	if (values == NULL) 
+	{
     	if(m==0)// return the structure of the jacobian of the constraints
     	{
-			iRow=NULL; 
-    			jCol=NULL;
-  		}
+    		iRow=NULL; 
+    		jCol=NULL;
+    	}
 
-		else
-		{
-			unsigned int i,j,idx=0;
-			for(int i=0;i<m;i++)
-				for(j=0;j<n;j++)
-				{
-					iRow[idx]=i;
-					jCol[idx]=j;
-					idx++;
-				}
-		}
-	}
-					
-  	else 
-	{
-		if(m==0)
-			values=NULL;
+    	else
+    	{
+    		unsigned int i,j,idx=0;
+    		for(int i=0;i<m;i++)
+    			for(j=0;j<n;j++)
+    			{
+    				iRow[idx]=i;
+    				jCol[idx]=j;
+    				idx++;
+    			}
+    		}
+    	}
+    	
+    	else 
+    	{
+    		if(m==0)
+    			values=NULL;
 
-		else
-		{
-			unsigned int i,j,c=0;
-			double check;
+    		else
+    		{
+    			unsigned int i,j,c=0;
+    			double check;
 			//jacobian of non-linear constraints
-			if(nonlinCon_!=0)
-			{
-					int* jacptr=NULL;
-  					if(getFunctionFromScilab(13,&jacptr))
-  					{
-						return 1;
-  					}  
-	
-  					const Number *xNew=x;
-  					createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
-  					int positionFirstElementOnStackForScilabFunction = 14;
-  					int numberOfRhsOnScilabFunction = 1;
-  					int numberOfLhsOnScilabFunction = 2;
-  					int pointerOnScilabFunction     = *jacptr;
-					char name[18]="addcGrad1";
- 	
-  					C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
-                        	                                       &numberOfLhsOnScilabFunction,
-                        	                                       &numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
-	
-					double* resj;  
-  					int xJ_rows,xJ_cols;
-  					if(getDoubleFromScilab(15,&check))
-  					{
-						return true;
-					}
-					if (check==1)
-					{
-						return true;
-					}	
-					else
-					{                                 
-  						if(getDoubleMatrixFromScilab(14, &xJ_rows, &xJ_cols, &resj))
-  						{
-							sciprint("No results");
-							return 1;
-						}
-	
-				        for(i=0;i<nonlinCon_;i++)
-						for(j=0;j<n;j++)
-						{
-							values[c] = resj[j*(int)nonlinCon_+i];
-							c++;
-						}
-					}			
-			}
+    			if(nonlinCon_!=0)
+    			{
+    				int* jacptr=NULL;
+    				if(getFunctionFromScilab(13,&jacptr))
+    				{
+    					return 1;
+    				}  
+    				
+    				const Number *xNew=x;
+    				createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
+    				int positionFirstElementOnStackForScilabFunction = 14;
+    				int numberOfRhsOnScilabFunction = 1;
+    				int numberOfLhsOnScilabFunction = 2;
+    				int pointerOnScilabFunction     = *jacptr;
+    				char name[18]="addcGrad1";
+    				
+    				C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
+    					&numberOfLhsOnScilabFunction,
+    					&numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
+    				
+    				double* resj;  
+    				int xJ_rows,xJ_cols;
+    				if(getDoubleFromScilab(15,&check))
+    				{
+    					return true;
+    				}
+    				if (check==1)
+    				{
+    					return true;
+    				}	
+    				else
+    				{                                 
+    					if(getDoubleMatrixFromScilab(14, &xJ_rows, &xJ_cols, &resj))
+    					{
+    						sciprint("No results");
+    						return 1;
+    					}
+    					
+    					for(i=0;i<nonlinCon_;i++)
+    						for(j=0;j<n;j++)
+    						{
+    							values[c] = resj[j*(int)nonlinCon_+i];
+    							c++;
+    						}
+    					}			
+    				}
 
 			//jacobian of linear equality constraints
-			for(i=0;i<Aeqrows_;i++)
-			{
-				for(j=0;j<Aeqcols_;j++)
-				{
-					values[c] = Aeq_[j*Aeqrows_+i];
-					c++;
-				}
-			}
+    				for(i=0;i<Aeqrows_;i++)
+    				{
+    					for(j=0;j<Aeqcols_;j++)
+    					{
+    						values[c] = Aeq_[j*Aeqrows_+i];
+    						c++;
+    					}
+    				}
 
 			//jacobian of linear inequality constraints
-			for(i=0;i<Arows_;i++)
-			{
-				for(j=0;j<Acols_;j++)
-				{
-					values[c] = A_[j*Arows_+i];
-					c++;
-				}
-			}
+    				for(i=0;i<Arows_;i++)
+    				{
+    					for(j=0;j<Acols_;j++)
+    					{
+    						values[c] = A_[j*Arows_+i];
+    						c++;
+    					}
+    				}
 
-		}	
-	}	
+    			}	
+    		}	
 
-  	return true;
-}
+    		return true;
+    	}
 
 /*
  * Return either the sparsity structure of the Hessian of the Lagrangian, 
@@ -418,168 +418,168 @@ bool minconNLP::eval_jac_g(Index n, const Number* x, bool new_x,Index m, Index n
  * x,lambda,obj_factor.
 */
 
-bool minconNLP::eval_h(Index n, const Number* x, bool new_x,Number obj_factor, Index m, const Number* lambda,bool new_lambda, Index nele_hess, Index* iRow,Index* jCol, Number* values)
-{
-	if (values==NULL)
-	{
-		Index idx=0;
-		for (Index row = 0; row < numVars_; row++) 
-		{
-			for (Index col = 0; col < numVars_; col++)
-			{
-				iRow[idx] = row;
-				jCol[idx] = col;
-				idx++;
-		  	}
-		}
-	}
-
-	else 
-	{
-		double check;
-		
-				int* hessptr=NULL;
-				if(getFunctionFromScilab(12,&hessptr))
-				{
-					return 1;
-				}          	
-				const Number *xNew=x;	
-				const Number *lambdaNew=lambda;
-				double objfac=obj_factor;
-  				createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
-				createScalarDouble(pvApiCtx, 15,objfac);
-				createMatrixOfDouble(pvApiCtx, 16, 1, numConstr_, lambdaNew);
-				int positionFirstElementOnStackForScilabFunction = 14;
-  				int numberOfRhsOnScilabFunction = 3;
-  				int numberOfLhsOnScilabFunction = 2;
-  				int pointerOnScilabFunction     = *hessptr;
-				char name[18]="lHess1";
-  		
-  				C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
-            	    	                                               &numberOfLhsOnScilabFunction,
-            	    	                                               &numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
-	
-				double* resCh;
-  				int xCh_rows,xCh_cols;
-  				if(getDoubleFromScilab(15,&check))
-  				{
-					return true;
-				}
-				if (check==1)
-				{
-					return true;
-				}	
-				else
-				{                           
-  					if(getDoubleMatrixFromScilab(14, &xCh_rows, &xCh_cols, &resCh))
-					{
-						sciprint("No results");
-						return 1;
-					}
-				
-					Index index=0;
-					for (Index row=0;row < numVars_ ;++row)
-					{
-						for (Index col=0; col < numVars_; ++col)
-						{
-							values[index++]=resCh[numVars_*row+col];
-						}
-					}
-				}
-
-		Index index=0;
-	        for (Index row=0;row < numVars_ ;++row)
-		{
-			for (Index col=0; col <= row; ++col)	
-			{
-				finalHessian_[n*row+col]=values[index++];
-			}
-		}
-
-		index=0;
-		for (Index col=0;col < numVars_ ;++col)
-		{
-			for (Index row=0; row <= col; ++row)	
-			{
-				finalHessian_[n*row+col]=values[index++];
-			}
-		}
-			
-	}	
-    return true;
-}
+    	bool minconNLP::eval_h(Index n, const Number* x, bool new_x,Number obj_factor, Index m, const Number* lambda,bool new_lambda, Index nele_hess, Index* iRow,Index* jCol, Number* values)
+    	{
+    		if (values==NULL)
+    		{
+    			Index idx=0;
+    			for (Index row = 0; row < numVars_; row++) 
+    			{
+    				for (Index col = 0; col < numVars_; col++)
+    				{
+    					iRow[idx] = row;
+    					jCol[idx] = col;
+    					idx++;
+    				}
+    			}
+    		}
+
+    		else 
+    		{
+    			double check;
+    			
+    			int* hessptr=NULL;
+    			if(getFunctionFromScilab(12,&hessptr))
+    			{
+    				return 1;
+    			}          	
+    			const Number *xNew=x;	
+    			const Number *lambdaNew=lambda;
+    			double objfac=obj_factor;
+    			createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
+    			createScalarDouble(pvApiCtx, 15,objfac);
+    			createMatrixOfDouble(pvApiCtx, 16, 1, numConstr_, lambdaNew);
+    			int positionFirstElementOnStackForScilabFunction = 14;
+    			int numberOfRhsOnScilabFunction = 3;
+    			int numberOfLhsOnScilabFunction = 2;
+    			int pointerOnScilabFunction     = *hessptr;
+    			char name[18]="lHess1";
+    			
+    			C2F(scistring)(&positionFirstElementOnStackForScilabFunction,name,
+    				&numberOfLhsOnScilabFunction,
+    				&numberOfRhsOnScilabFunction,(unsigned long)strlen(name));
+    			
+    			double* resCh;
+    			int xCh_rows,xCh_cols;
+    			if(getDoubleFromScilab(15,&check))
+    			{
+    				return true;
+    			}
+    			if (check==1)
+    			{
+    				return true;
+    			}	
+    			else
+    			{                           
+    				if(getDoubleMatrixFromScilab(14, &xCh_rows, &xCh_cols, &resCh))
+    				{
+    					sciprint("No results");
+    					return 1;
+    				}
+    				
+    				Index index=0;
+    				for (Index row=0;row < numVars_ ;++row)
+    				{
+    					for (Index col=0; col < numVars_; ++col)
+    					{
+    						values[index++]=resCh[numVars_*row+col];
+    					}
+    				}
+    			}
+
+    			Index index=0;
+    			for (Index row=0;row < numVars_ ;++row)
+    			{
+    				for (Index col=0; col <= row; ++col)	
+    				{
+    					finalHessian_[n*row+col]=values[index++];
+    				}
+    			}
+
+    			index=0;
+    			for (Index col=0;col < numVars_ ;++col)
+    			{
+    				for (Index row=0; row <= col; ++row)	
+    				{
+    					finalHessian_[n*row+col]=values[index++];
+    				}
+    			}
+    			
+    		}	
+    		return true;
+    	}
 
 //returning the results
-void minconNLP::finalize_solution(SolverReturn status,Index n, const Number* x, const Number* z_L, const Number* z_U,Index m, const Number* g, const Number* lambda, Number obj_value,const IpoptData* ip_data,IpoptCalculatedQuantities* ip_cq)
-{
-	finalX_ = new double[n];
-	for (Index i=0; i<n; i++) 
-	{
-    		 finalX_[i] = x[i];
-	}
-	
-	 finalZl_ = new double[n];
-	for (Index i=0; i<n; i++) 
-	{
-    		 finalZl_[i] = z_L[i];
-	}
-
-	finalZu_ = new double[n];
-	for (Index i=0; i<n; i++) 
-	{
-    		 finalZu_[i] = z_U[i];
-	}
-
-	finalLambda_ = new double[m];
-	for (Index i=0; i<m; i++) 
-	{
-    		 finalLambda_[i] = lambda[i];
-	}
-
-	finalObjVal_ = obj_value;
-	status_ = status;
-}
-
-
-const double * minconNLP::getX()
-{	
-	return finalX_;
-}
-
-const double * minconNLP::getGrad()
-{	
-	return finalGradient_;
-}
-
-const double * minconNLP::getHess()
-{	
-	return finalHessian_;
-}
-
-const double * minconNLP::getZl()
-{	
-	return finalZl_;
-}
-
-const double * minconNLP::getZu()
-{	
-	return finalZu_;
-}
-
-const double * minconNLP::getLambda()
-{	
-	return finalLambda_;
-}
-
-double minconNLP::getObjVal()
-{	
-	return finalObjVal_;
-}
-
-int minconNLP::returnStatus()
-{	
-	return status_;
-}
-
-}
+    	void minconNLP::finalize_solution(SolverReturn status,Index n, const Number* x, const Number* z_L, const Number* z_U,Index m, const Number* g, const Number* lambda, Number obj_value,const IpoptData* ip_data,IpoptCalculatedQuantities* ip_cq)
+    	{
+    		finalX_ = new double[n];
+    		for (Index i=0; i<n; i++) 
+    		{
+    			finalX_[i] = x[i];
+    		}
+    		
+    		finalZl_ = new double[n];
+    		for (Index i=0; i<n; i++) 
+    		{
+    			finalZl_[i] = z_L[i];
+    		}
+
+    		finalZu_ = new double[n];
+    		for (Index i=0; i<n; i++) 
+    		{
+    			finalZu_[i] = z_U[i];
+    		}
+
+    		finalLambda_ = new double[m];
+    		for (Index i=0; i<m; i++) 
+    		{
+    			finalLambda_[i] = lambda[i];
+    		}
+
+    		finalObjVal_ = obj_value;
+    		status_ = status;
+    	}
+
+
+    	const double * minconNLP::getX()
+    	{	
+    		return finalX_;
+    	}
+
+    	const double * minconNLP::getGrad()
+    	{	
+    		return finalGradient_;
+    	}
+
+    	const double * minconNLP::getHess()
+    	{	
+    		return finalHessian_;
+    	}
+
+    	const double * minconNLP::getZl()
+    	{	
+    		return finalZl_;
+    	}
+
+    	const double * minconNLP::getZu()
+    	{	
+    		return finalZu_;
+    	}
+
+    	const double * minconNLP::getLambda()
+    	{	
+    		return finalLambda_;
+    	}
+
+    	double minconNLP::getObjVal()
+    	{	
+    		return finalObjVal_;
+    	}
+
+    	int minconNLP::returnStatus()
+    	{	
+    		return status_;
+    	}
+
+    }
 
diff --git a/sci_gateway/cpp/sci_sym_loadproblem.cpp b/sci_gateway/cpp/sci_sym_loadproblem.cpp
index 1a00092..f0df922 100644
--- a/sci_gateway/cpp/sci_sym_loadproblem.cpp
+++ b/sci_gateway/cpp/sci_sym_loadproblem.cpp
@@ -235,7 +235,7 @@ static int commonCodePart2()
 	
 	//call problem loader
 	sym_explicit_load_problem(global_sym_env,numVars,numConstr,conMatrixColStart,conMatrixRowIndex,conMatrix,lowerBounds,upperBounds,isIntVar,objective,NULL,conType,conRHS,conRange,TRUE);
-	sciprint("Problem loaded into environment.\n");
+	// sciprint("Problem loaded into environment.\n");
 	
 	//code to give output
 	cleanupBeforeExit();
diff --git a/sci_gateway/cpp/sci_sym_openclose.cpp b/sci_gateway/cpp/sci_sym_openclose.cpp
index 90bfe75..301854f 100644
--- a/sci_gateway/cpp/sci_sym_openclose.cpp
+++ b/sci_gateway/cpp/sci_sym_openclose.cpp
@@ -36,6 +36,8 @@ int sci_sym_open(char *fname, unsigned long fname_len){
 
 	//check environment
 	if(global_sym_env==NULL){
+	// 	sciprint("Warning: Symphony environment is already initialized.\n");
+	// }else{
 		global_sym_env = sym_open_environment();//open an environment
 		if (!global_sym_env)
 			sciprint("Error: Unable to create symphony environment.\n");
diff --git a/sci_gateway/cpp/sci_sym_set_variables.cpp b/sci_gateway/cpp/sci_sym_set_variables.cpp
index 9368d69..17f9ac2 100644
--- a/sci_gateway/cpp/sci_sym_set_variables.cpp
+++ b/sci_gateway/cpp/sci_sym_set_variables.cpp
@@ -233,7 +233,7 @@ int sci_sym_set_dbl_param(char *fname, unsigned long fname_len){
 	else {
 		output=sym_set_dbl_param(global_sym_env,ptr,num);//symphony function to set the variable name pointed by the ptr pointer to the double value stored in 'value' variable.
 		if(output==FUNCTION_TERMINATED_NORMALLY){		
-			sciprint("setting of double parameter function executed successfully\n");
+			// sciprint("setting of double parameter function executed successfully\n");
 			status=0.0;
 		}
 		else
diff --git a/sci_gateway/cpp/sci_sym_solve.cpp b/sci_gateway/cpp/sci_sym_solve.cpp
index a0af480..e15535b 100644
--- a/sci_gateway/cpp/sci_sym_solve.cpp
+++ b/sci_gateway/cpp/sci_sym_solve.cpp
@@ -38,9 +38,9 @@ int sci_sym_solve(char *fname, unsigned long fname_len){
 		status = sym_get_dbl_param(global_sym_env,"time_limit",&time_limit);
 
 		if (status == FUNCTION_TERMINATED_NORMALLY) {
-			if ( time_limit < 0.0 )
-				sciprint("\nNote: There is no limit on time.\n");
-			else sciprint("\nNote: Time limit has been set to %lf.\n",time_limit);
+			if ( time_limit >= 0.0 )
+				// sciprint("\nNote: There is no limit on time.\n");
+			sciprint("\nNote: Time limit has been set to %lf.\n",time_limit);
 			status=process_ret_val(sym_solve(global_sym_env));// Call function	
 			}
 		else {
diff --git a/thirdparty/linux/include/coin/IpAlgBuilder.hpp b/thirdparty/linux/include/coin/IpAlgBuilder.hpp
new file mode 100644
index 0000000..05692bb
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpAlgBuilder.hpp
@@ -0,0 +1,360 @@
+// Copyright (C) 2004, 2007 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpAlgBuilder.hpp 2666 2016-07-20 16:02:55Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-09-29
+
+#ifndef __IPALGBUILDER_HPP__
+#define __IPALGBUILDER_HPP__
+
+#include "IpIpoptAlg.hpp"
+#include "IpReferenced.hpp"
+#include "IpAugSystemSolver.hpp"
+#include "IpPDSystemSolver.hpp"
+
+namespace Ipopt
+{
+
+  // forward declarations
+  class IterationOutput;
+  class HessianUpdater;
+  class ConvergenceCheck;
+  class SearchDirectionCalculator;
+  class EqMultiplierCalculator;
+  class IterateInitializer;
+  class LineSearch;
+  class MuUpdate;
+
+  /** Builder for creating a complete IpoptAlg object.  This object
+   *  contains all subelements (such as line search objects etc).  How
+   *  the resulting IpoptAlg object is built can be influenced by the
+   *  options.
+   *
+   *  More advanced customization can be achieved by subclassing this
+   *  class and overloading the virtual methods that build the
+   *  individual parts. The advantage of doing this is that it allows
+   *  one to reuse the extensive amount of options processing that
+   *  takes place, for instance, when generating the symmetric linear
+   *  system solver. Another method for customizing the algorithm is
+   *  using the optional custom_solver argument, which allows the
+   *  expert user to provide a specialized linear solver for the
+   *  augmented system (e.g., type GenAugSystemSolver), possibly for
+   *  user-defined matrix objects. The optional custom_solver constructor
+   *  argument is likely obsolete, however, as more control over this
+   *  this process can be achieved by implementing a subclass of this
+   *  AlgBuilder (e.g., by overloading the AugSystemSolverFactory method).
+   */
+  class AlgorithmBuilder : public ReferencedObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Constructor */
+    AlgorithmBuilder(SmartPtr<AugSystemSolver> custom_solver=NULL);
+
+    /** Destructor */
+    virtual ~AlgorithmBuilder()
+    {}
+
+    //@}
+
+    /** Methods for IpoptTypeInfo */
+    //@{
+    /** register the options used by the algorithm builder */
+    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
+    //@}
+
+    /** @name Convenience methods for building solvers without having
+     *  to duplicate the significant amount of preprocessor flag and
+     *  option checking that takes place. These solvers are used to
+     *  create a number of core algorithm components across the
+     *  different Build* methods, but depending on what options are
+     *  chosen, the first method requiring the solver to be used can
+     *  vary. Therefore, each of the Factory methods below is paired
+     *  with a Getter method, which is called by all parts of this
+     *  algorithm builder to ensure the Factory is only called once. */
+    //@{
+
+    /** Create a solver that can be used to solve a symmetric linear
+     *  system.
+     *  Dependencies: None
+     */
+    virtual SmartPtr<SymLinearSolver>
+        SymLinearSolverFactory(const Journalist& jnlst,
+                               const OptionsList& options,
+                               const std::string& prefix);
+
+    /** Get the symmetric linear system solver for this
+     *  algorithm. This method will call the SymLinearSolverFactory
+     *  exactly once (the first time it is used), and store its
+     *  instance on SymSolver_ for use in subsequent calls.
+     */
+    SmartPtr<SymLinearSolver> GetSymLinearSolver(const Journalist& jnlst,
+                                                 const OptionsList& options,
+                                                 const std::string& prefix);
+
+    /** Create a solver that can be used to solve an
+     *  augmented system.
+     *  Dependencies:
+     *     -> GetSymLinearSolver()
+     *         -> SymLinearSolverFactory()
+     *     -> custom_solver_
+     */
+    virtual SmartPtr<AugSystemSolver>
+        AugSystemSolverFactory(const Journalist& jnlst,
+                               const OptionsList& options,
+                               const std::string& prefix);
+
+    /** Get the augmented system solver for this algorithm. This
+     *  method will call the AugSystemSolverFactory exactly once (the
+     *  first time it is used), and store its instance on AugSolver_
+     *  for use in subsequent calls.
+     */
+    SmartPtr<AugSystemSolver> GetAugSystemSolver(const Journalist& jnlst,
+                                                 const OptionsList& options,
+                                                 const std::string& prefix);
+
+    /** Create a solver that can be used to solve a
+     *  primal-dual system.
+     *  Dependencies:
+     *     -> GetAugSystemSolver()
+     *         -> AugSystemSolverFactory()
+     *             -> GetSymLinearSolver()
+     *                 -> SymLinearSolverFactory()
+     *             -> custom_solver_
+     */
+    virtual SmartPtr<PDSystemSolver>
+        PDSystemSolverFactory(const Journalist& jnlst,
+                              const OptionsList& options,
+                              const std::string& prefix);
+
+    /** Get the primal-dual system solver for this algorithm. This
+     *  method will call the PDSystemSolverFactory exactly once (the
+     *  first time it is used), and store its instance on PDSolver_
+     *  for use in subsequent calls.
+     */
+    SmartPtr<PDSystemSolver> GetPDSystemSolver(const Journalist& jnlst,
+                                               const OptionsList& options,
+                                               const std::string& prefix);
+    //@}
+
+    /** @name Methods to build parts of the algorithm */
+    //@{
+    /** Allocates memory for the IpoptNLP, IpoptData, and
+     *  IpoptCalculatedQuanties arguments.
+     *  Dependencies: None
+     */
+    virtual void BuildIpoptObjects(const Journalist& jnlst,
+                                   const OptionsList& options,
+                                   const std::string& prefix,
+                                   const SmartPtr<NLP>& nlp,
+                                   SmartPtr<IpoptNLP>& ip_nlp,
+                                   SmartPtr<IpoptData>& ip_data,
+                                   SmartPtr<IpoptCalculatedQuantities>& ip_cq);
+
+    /** Creates an instance of the IpoptAlgorithm class by building
+     *  each of its required constructor arguments piece-by-piece. The
+     *  default algorithm can be customized by overloading this method
+     *  or by overloading one or more of the Build* methods called in
+     *  this method's default implementation. Additional control can
+     *  be achieved by overloading any of the *SolverFactory methods.
+     *  This method will call (in this order):
+     *     -> BuildIterationOutput()
+     *     -> BuildHessianUpdater()
+     *     -> BuildConvergenceCheck()
+     *     -> BuildSearchDirectionCalculator()
+     *     -> BuildEqMultiplierCalculator()
+     *     -> BuildIterateInitializer()
+     *     -> BuildLineSearch()
+     *     -> BuildMuUpdate()
+     */
+    virtual SmartPtr<IpoptAlgorithm> BuildBasicAlgorithm(const Journalist& jnlst,
+        const OptionsList& options,
+        const std::string& prefix);
+
+    /** Creates an instance of the IterationOutput class. This method
+     *  is called in the default implementation of
+     *  BuildBasicAlgorithm. It can be overloaded to customize that
+     *  portion the default algorithm.
+     *  Dependencies: None
+     */
+    virtual SmartPtr<IterationOutput>
+        BuildIterationOutput(const Journalist& jnlst,
+                             const OptionsList& options,
+                             const std::string& prefix);
+
+    /** Creates an instance of the HessianUpdater class. This method
+     *  is called in the default implementation of
+     *  BuildBasicAlgorithm.  It can be overloaded to customize that
+     *  portion the default algorithm.
+     *  Dependencies: None
+     */
+    virtual SmartPtr<HessianUpdater>
+        BuildHessianUpdater(const Journalist& jnlst,
+                            const OptionsList& options,
+                            const std::string& prefix);
+
+    /** Creates an instance of the ConvergenceCheck class. This method
+     *  is called in the default implementation of
+     *  BuildBasicAlgorithm.  It can be overloaded to customize that
+     *  portion the default algorithm.
+     *  Dependencies: None
+     */
+    virtual SmartPtr<ConvergenceCheck>
+        BuildConvergenceCheck(const Journalist& jnlst,
+                              const OptionsList& options,
+                              const std::string& prefix);
+
+    /** Creates an instance of the SearchDirectionCalculator
+     *  class. This method is called in the default implementation of
+     *  BuildBasicAlgorithm.  It can be overloaded to customize that
+     *  portion the default algorithm.
+     *  Dependencies:
+     *     -> GetPDSystemSolver()
+     *         -> PDSystemSolverFactory()
+     *             -> GetAugSystemSolver()
+     *                 -> AugSystemSolverFactory()
+     *                     -> GetSymLinearSolver()
+     *                         -> SymLinearSolverFactory()
+     *                     -> custom_solver_
+     */
+     virtual SmartPtr<SearchDirectionCalculator>
+        BuildSearchDirectionCalculator(const Journalist& jnlst,
+                                       const OptionsList& options,
+                                       const std::string& prefix);
+
+    /** Creates an instance of the EqMultiplierCalculator class. This
+     *  method is called in the default implementation of
+     *  BuildBasicAlgorithm.  It can be overloaded to customize that
+     *  portion the default algorithm.
+     *  Dependencies:
+     *     -> GetAugSystemSolver()
+     *         -> AugSystemSolverFactory()
+     *             -> GetSymLinearSolver()
+     *                 -> SymLinearSolverFactory()
+     *             -> custom_solver_
+     */
+    virtual SmartPtr<EqMultiplierCalculator>
+        BuildEqMultiplierCalculator(const Journalist& jnlst,
+                                    const OptionsList& options,
+                                    const std::string& prefix);
+
+    /** Creates an instance of the IterateInitializer class. This
+     *  method is called in the default implementation of
+     *  BuildBasicAlgorithm.  It can be overloaded to customize that
+     *  portion the default algorithm.
+     *  Dependencies:
+     *     -> EqMultCalculator_
+     *     -> GetAugSystemSolver()
+     *         -> AugSystemSolverFactory()
+     *             -> GetSymLinearSolver()
+     *                 -> SymLinearSolverFactory()
+     *             -> custom_solver_
+     */
+    virtual SmartPtr<IterateInitializer>
+        BuildIterateInitializer(const Journalist& jnlst,
+                                const OptionsList& options,
+                                const std::string& prefix);
+
+    /** Creates an instance of the LineSearch class. This method is
+     *  called in the default implementation of BuildBasicAlgorithm.
+     *  It can be overloaded to customize that portion the default
+     *  algorithm.
+     *  Dependencies:
+     *     -> EqMultCalculator_
+     *     -> ConvCheck_
+     *     -> GetAugSystemSolver()
+     *         -> AugSystemSolverFactory()
+     *             -> GetSymLinearSolver()
+     *                 -> SymLinearSolverFactory()
+     *             -> custom_solver_
+     *     -> GetPDSystemSolver()
+     *         -> PDSystemSolverFactory()
+     *             -> GetAugSystemSolver()
+     *                 -> AugSystemSolverFactory()
+     *                     -> GetSymLinearSolver()
+     *                         -> SymLinearSolverFactory()
+     *                     -> custom_solver_
+     */
+    virtual SmartPtr<LineSearch> BuildLineSearch(const Journalist& jnlst,
+                                                 const OptionsList& options,
+                                                 const std::string& prefix);
+
+    /** Creates an instance of the MuUpdate class. This method is
+     *  called in the default implementation of BuildBasicAlgorithm.
+     *  It can be overloaded to customize that portion the default
+     *  algorithm.
+     *  Dependencies:
+     *     -> LineSearch_
+     *         -> EqMultCalculator_
+     *         -> ConvCheck_
+     *     -> GetPDSystemSolver()
+     *         -> PDSystemSolverFactory()
+     *             -> GetAugSystemSolver()
+     *                 -> AugSystemSolverFactory()
+     *                     -> GetSymLinearSolver()
+     *                         -> SymLinearSolverFactory()
+     *                     -> custom_solver_
+     */
+    virtual SmartPtr<MuUpdate> BuildMuUpdate(const Journalist& jnlst,
+                                             const OptionsList& options,
+                                             const std::string& prefix);
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    //AlgorithmBuilder();
+
+    /** Copy Constructor */
+    AlgorithmBuilder(const AlgorithmBuilder&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const AlgorithmBuilder&);
+    //@}
+
+    /** @name IpoptAlgorithm constructor arguments.
+     *  These components are built in separate Build
+     *  methods in the order defined by BuildBasicAlgorithm.
+     *  A single core component may require one or more
+     *  other core components in its constructor, so the
+     *  this class holds pointers to each component for use
+     *  between the separate Build methods. */
+    //@{
+    SmartPtr<IterationOutput> IterOutput_;
+    SmartPtr<HessianUpdater> HessUpdater_;
+    SmartPtr<ConvergenceCheck> ConvCheck_;
+    SmartPtr<SearchDirectionCalculator> SearchDirCalc_;
+    SmartPtr<EqMultiplierCalculator> EqMultCalculator_;
+    SmartPtr<IterateInitializer> IterInitializer_;
+    SmartPtr<LineSearch> LineSearch_;
+    SmartPtr<MuUpdate> MuUpdate_;
+    //@}
+
+    /** @name Commonly used solver components
+     *  for building core algorithm components. Each
+     *  of these members is paired with a Factory/Getter
+     *  method. */
+    //@{
+    SmartPtr<SymLinearSolver> SymSolver_;
+    SmartPtr<AugSystemSolver> AugSolver_;
+    SmartPtr<PDSystemSolver> PDSolver_;
+    //@}
+
+    /** Optional pointer to AugSystemSolver.  If this is set in the
+     *  contructor, we will use this to solve the linear systems. */
+    SmartPtr<AugSystemSolver> custom_solver_;
+
+  };
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpAlgStrategy.hpp b/thirdparty/linux/include/coin/IpAlgStrategy.hpp
new file mode 100644
index 0000000..746a968
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpAlgStrategy.hpp
@@ -0,0 +1,185 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpAlgStrategy.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPALGSTRATEGY_HPP__
+#define __IPALGSTRATEGY_HPP__
+
+#include "IpOptionsList.hpp"
+#include "IpJournalist.hpp"
+#include "IpIpoptCalculatedQuantities.hpp"
+#include "IpIpoptNLP.hpp"
+#include "IpIpoptData.hpp"
+
+namespace Ipopt
+{
+
+  /** This is the base class for all algorithm strategy objects.  The
+   *  AlgorithmStrategyObject base class implements a common interface
+   *  for all algorithm strategy objects.  A strategy object is a
+   *  component of the algorithm for which different alternatives or
+   *  implementations exists.  It allows to compose the algorithm
+   *  before execution for a particular configuration, without the
+   *  need to call alternatives based on enums. For example, the
+   *  LineSearch object is a strategy object, since different line
+   *  search options might be used for different runs.
+   *
+   *  This interface is used for
+   *  things that are done to all strategy objects, like
+   *  initialization and setting options.
+   */
+  class AlgorithmStrategyObject : public ReferencedObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    AlgorithmStrategyObject()
+        :
+        initialize_called_(false)
+    {}
+
+    /** Default Destructor */
+    virtual ~AlgorithmStrategyObject()
+    {}
+    //@}
+
+    /** This method is called every time the algorithm starts again -
+     *  it is used to reset any internal state.  The pointers to the
+     *  Journalist, as well as to the IpoptNLP, IpoptData, and
+     *  IpoptCalculatedQuantities objects should be stored in the
+     *  instanciation of this base class.  This method is also used to
+     *  get all required user options from the OptionsList.  Here, if
+     *  prefix is given, each tag (identifying the options) is first
+     *  looked for with the prefix in front, and if not found, without
+     *  the prefix.  Note: you should not cue off of the iteration
+     *  count to indicate the "start" of an algorithm!
+     *
+     *  Do not overload this method, since it does some general
+     *  initialization that is common for all strategy objects.
+     *  Overload the protected InitializeImpl method instead.
+     */
+    bool Initialize(const Journalist& jnlst,
+                    IpoptNLP& ip_nlp,
+                    IpoptData& ip_data,
+                    IpoptCalculatedQuantities& ip_cq,
+                    const OptionsList& options,
+                    const std::string& prefix)
+    {
+      initialize_called_ = true;
+      // Copy the pointers for the problem defining objects
+      jnlst_ = &jnlst;
+      ip_nlp_ = &ip_nlp;
+      ip_data_ = &ip_data;
+      ip_cq_ = &ip_cq;
+
+      bool retval = InitializeImpl(options, prefix);
+      if (!retval) {
+        initialize_called_ = false;
+      }
+
+      return retval;
+    }
+
+    /** Reduced version of the Initialize method, which does not
+     *  require special Ipopt information.  This is useful for
+     *  algorithm objects that could be used outside Ipopt, such as
+     *  linear solvers. */
+    bool ReducedInitialize(const Journalist& jnlst,
+                           const OptionsList& options,
+                           const std::string& prefix)
+    {
+      initialize_called_ = true;
+      // Copy the pointers for the problem defining objects
+      jnlst_ = &jnlst;
+      ip_nlp_ = NULL;
+      ip_data_ = NULL;
+      ip_cq_ = NULL;
+
+      bool retval = InitializeImpl(options, prefix);
+      if (!retval) {
+        initialize_called_ = false;
+      }
+
+      return retval;
+    }
+
+  protected:
+    /** Implementation of the initialization method that has to be
+     *  overloaded by for each derived class. */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix)=0;
+
+    /** @name Accessor methods for the problem defining objects.
+     *  Those should be used by the derived classes. */
+    //@{
+    const Journalist& Jnlst() const
+    {
+      DBG_ASSERT(initialize_called_);
+      return *jnlst_;
+    }
+    IpoptNLP& IpNLP() const
+    {
+      DBG_ASSERT(initialize_called_);
+      DBG_ASSERT(IsValid(ip_nlp_));
+      return *ip_nlp_;
+    }
+    IpoptData& IpData() const
+    {
+      DBG_ASSERT(initialize_called_);
+      DBG_ASSERT(IsValid(ip_data_));
+      return *ip_data_;
+    }
+    IpoptCalculatedQuantities& IpCq() const
+    {
+      DBG_ASSERT(initialize_called_);
+      DBG_ASSERT(IsValid(ip_cq_));
+      return *ip_cq_;
+    }
+    bool HaveIpData() const
+    {
+      return IsValid(ip_data_);
+    }
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    //AlgorithmStrategyObject();
+
+
+    /** Copy Constructor */
+    AlgorithmStrategyObject(const AlgorithmStrategyObject&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const AlgorithmStrategyObject&);
+    //@}
+
+    /** @name Pointers to objects defining a particular optimization
+     *  problem */
+    //@{
+    SmartPtr<const Journalist> jnlst_;
+    SmartPtr<IpoptNLP> ip_nlp_;
+    SmartPtr<IpoptData> ip_data_;
+    SmartPtr<IpoptCalculatedQuantities> ip_cq_;
+    //@}
+
+    /** flag indicating if Initialize method has been called (for
+     *  debugging) */
+    bool initialize_called_;
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpAugSystemSolver.hpp b/thirdparty/linux/include/coin/IpAugSystemSolver.hpp
new file mode 100644
index 0000000..1396ce4
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpAugSystemSolver.hpp
@@ -0,0 +1,200 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpAugSystemSolver.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IP_AUGSYSTEMSOLVER_HPP__
+#define __IP_AUGSYSTEMSOLVER_HPP__
+
+#include "IpSymMatrix.hpp"
+#include "IpSymLinearSolver.hpp"
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+  DECLARE_STD_EXCEPTION(FATAL_ERROR_IN_LINEAR_SOLVER);
+
+  /** Base class for Solver for the augmented system.  This is the
+   *  base class for linear solvers that solve the augmented system,
+   *  which is defined as
+   *
+   *  \f$\left[\begin{array}{cccc}
+   *  W + D_x + \delta_xI & 0 & J_c^T & J_d^T\\
+   *  0 & D_s + \delta_sI & 0 & -I \\
+   *  J_c & 0 & D_c - \delta_cI & 0\\
+   *  J_d & -I & 0 & D_d - \delta_dI
+   *  \end{array}\right]
+   *  \left(\begin{array}{c}sol_x\\sol_s\\sol_c\\sol_d\end{array}\right)=
+   *  \left(\begin{array}{c}rhs_x\\rhs_s\\rhs_c\\rhs_d\end{array}\right)\f$
+   *
+   *  Since this system might be solved repeatedly for different right
+   *  hand sides, it is desirable to step the factorization of a
+   *  direct linear solver if possible.
+   */
+  class AugSystemSolver: public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default constructor. */
+    AugSystemSolver()
+    {}
+    /** Default destructor */
+    virtual ~AugSystemSolver()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Set up the augmented system and solve it for a given right hand
+     *  side.  If desired (i.e. if check_NegEVals is true), then the
+     *  solution is only computed if the number of negative eigenvalues
+     *  matches numberOfNegEVals.
+     *
+     *  The return value is the return value of the linear solver object.
+     */
+    virtual ESymSolverStatus Solve(
+      const SymMatrix* W,
+      double W_factor,
+      const Vector* D_x,
+      double delta_x,
+      const Vector* D_s,
+      double delta_s,
+      const Matrix* J_c,
+      const Vector* D_c,
+      double delta_c,
+      const Matrix* J_d,
+      const Vector* D_d,
+      double delta_d,
+      const Vector& rhs_x,
+      const Vector& rhs_s,
+      const Vector& rhs_c,
+      const Vector& rhs_d,
+      Vector& sol_x,
+      Vector& sol_s,
+      Vector& sol_c,
+      Vector& sol_d,
+      bool check_NegEVals,
+      Index numberOfNegEVals)
+    {
+      std::vector<SmartPtr<const Vector> > rhs_xV(1);
+      rhs_xV[0] = &rhs_x;
+      std::vector<SmartPtr<const Vector> > rhs_sV(1);
+      rhs_sV[0] = &rhs_s;
+      std::vector<SmartPtr<const Vector> > rhs_cV(1);
+      rhs_cV[0] = &rhs_c;
+      std::vector<SmartPtr<const Vector> > rhs_dV(1);
+      rhs_dV[0] = &rhs_d;
+      std::vector<SmartPtr<Vector> > sol_xV(1);
+      sol_xV[0] = &sol_x;
+      std::vector<SmartPtr<Vector> > sol_sV(1);
+      sol_sV[0] = &sol_s;
+      std::vector<SmartPtr<Vector> > sol_cV(1);
+      sol_cV[0] = &sol_c;
+      std::vector<SmartPtr<Vector> > sol_dV(1);
+      sol_dV[0] = &sol_d;
+      return MultiSolve(W, W_factor, D_x, delta_x, D_s, delta_s, J_c, D_c, delta_c,
+                        J_d, D_d, delta_d, rhs_xV, rhs_sV, rhs_cV, rhs_dV,
+                        sol_xV, sol_sV, sol_cV, sol_dV, check_NegEVals,
+                        numberOfNegEVals);
+    }
+
+    /** Like Solve, but for multiple right hand sides.  The inheriting
+     *  class has to be overload at least one of Solve and
+     *  MultiSolve. */
+    virtual ESymSolverStatus MultiSolve(
+      const SymMatrix* W,
+      double W_factor,
+      const Vector* D_x,
+      double delta_x,
+      const Vector* D_s,
+      double delta_s,
+      const Matrix* J_c,
+      const Vector* D_c,
+      double delta_c,
+      const Matrix* J_d,
+      const Vector* D_d,
+      double delta_d,
+      std::vector<SmartPtr<const Vector> >& rhs_xV,
+      std::vector<SmartPtr<const Vector> >& rhs_sV,
+      std::vector<SmartPtr<const Vector> >& rhs_cV,
+      std::vector<SmartPtr<const Vector> >& rhs_dV,
+      std::vector<SmartPtr<Vector> >& sol_xV,
+      std::vector<SmartPtr<Vector> >& sol_sV,
+      std::vector<SmartPtr<Vector> >& sol_cV,
+      std::vector<SmartPtr<Vector> >& sol_dV,
+      bool check_NegEVals,
+      Index numberOfNegEVals)
+    {
+      // Solve for one right hand side after the other
+      Index nrhs = (Index)rhs_xV.size();
+      DBG_ASSERT(nrhs>0);
+      DBG_ASSERT(nrhs==(Index)rhs_sV.size());
+      DBG_ASSERT(nrhs==(Index)rhs_cV.size());
+      DBG_ASSERT(nrhs==(Index)rhs_dV.size());
+      DBG_ASSERT(nrhs==(Index)sol_xV.size());
+      DBG_ASSERT(nrhs==(Index)sol_sV.size());
+      DBG_ASSERT(nrhs==(Index)sol_cV.size());
+      DBG_ASSERT(nrhs==(Index)sol_dV.size());
+
+      ESymSolverStatus retval=SYMSOLVER_SUCCESS;
+      for (Index i=0; i<nrhs; i++) {
+        retval = Solve(W, W_factor, D_x, delta_x, D_s, delta_s, J_c, D_c, delta_c,
+                       J_d, D_d, delta_d,
+                       *rhs_xV[i], *rhs_sV[i], *rhs_cV[i], *rhs_dV[i],
+                       *sol_xV[i], *sol_sV[i], *sol_cV[i], *sol_dV[i],
+                       check_NegEVals, numberOfNegEVals);
+        if (retval!=SYMSOLVER_SUCCESS) {
+          break;
+        }
+      }
+      return retval;
+    }
+
+    /** Number of negative eigenvalues detected during last
+     * solve.  Returns the number of negative eigenvalues of
+     * the most recent factorized matrix.  This must not be called if
+     * the linear solver does not compute this quantities (see
+     * ProvidesInertia).
+     */
+    virtual Index NumberOfNegEVals() const =0;
+
+    /** Query whether inertia is computed by linear solver.
+     *  Returns true, if linear solver provides inertia.
+     */
+    virtual bool ProvidesInertia() const =0;
+
+    /** Request to increase quality of solution for next solve.  Ask
+     *  underlying linear solver to increase quality of solution for
+     *  the next solve (e.g. increase pivot tolerance).  Returns
+     *  false, if this is not possible (e.g. maximal pivot tolerance
+     *  already used.)
+     */
+    virtual bool IncreaseQuality() =0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Copy Constructor */
+    AugSystemSolver(const AugSystemSolver&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const AugSystemSolver&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpCompoundMatrix.hpp b/thirdparty/linux/include/coin/IpCompoundMatrix.hpp
new file mode 100644
index 0000000..03e2e2a
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpCompoundMatrix.hpp
@@ -0,0 +1,340 @@
+// Copyright (C) 2004, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpCompoundMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPCOMPOUNDMATRIX_HPP__
+#define __IPCOMPOUNDMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class CompoundMatrixSpace;
+
+  /** Class for Matrices consisting of other matrices.  This matrix is
+   *  a matrix that consists of zero, one or more Matrices's which are
+   *  arranged like this: \f$ M_{\rm compound} =
+   *  \left(\begin{array}{cccc}M_{00} & M_{01} & \ldots & M_{0,{\rm
+   *  ncomp\_cols}-1} \\ \dots &&&\dots \\ M_{{\rm ncomp\_rows}-1,0} &
+   *  M_{{\rm ncomp\_rows}-1,1} & \dots & M_{{\rm ncomp\_rows}-1,{\rm
+   *  ncomp\_cols}-1}\end{array}\right)\f$.  The individual components
+   *  can be associated to different MatrixSpaces.  The individual
+   *  components can also be const and non-const Matrices.  If a
+   *  component is not set (i.e., it's pointer is NULL), then this
+   *  components is treated like a zero-matrix of appropriate
+   *  dimensions.
+   */
+  class CompoundMatrix : public Matrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the owner_space.  The owner_space has to
+     *  be defined, so that at each block row and column contain at
+     *  least one non-NULL component.  The individual components can
+     *  be set afterwards with the SeteComp and SetCompNonConst
+     *  methods.
+     */
+    CompoundMatrix(const CompoundMatrixSpace* owner_space);
+
+    /** Destructor */
+    virtual ~CompoundMatrix();
+    //@}
+
+    /** Method for setting an individual component at position (irow,
+     *  icol) in the compound matrix.  The counting of indices starts
+     *  at 0. */
+    void SetComp(Index irow, Index jcol, const Matrix& matrix);
+
+    /** Method to set a non-const Matrix entry */
+    void SetCompNonConst(Index irow, Index jcol, Matrix& matrix);
+
+    /** Method to create a new matrix from the space for this block */
+    void CreateBlockFromSpace(Index irow, Index jcol);
+
+    /** Method for retrieving one block from the compound matrix as a
+     *  const Matrix.
+     */
+    SmartPtr<const Matrix> GetComp(Index irow, Index jcol) const
+    {
+      return ConstComp(irow, jcol);
+    }
+
+    /** Method for retrieving one block from the compound matrix as a
+     *  non-const Matrix.  Note that calling this method with mark the
+     *  CompoundMatrix as changed.  Therefore, only use this method if
+     *  you are intending to change the Matrix that you receive. */
+    SmartPtr<Matrix> GetCompNonConst(Index irow, Index jcol)
+    {
+      ObjectChanged();
+      return Comp(irow, jcol);
+    }
+
+    /** Number of block rows of this compound matrix. */
+    inline Index NComps_Rows() const;
+    /** Number of block colmuns of this compound matrix. */
+    inline Index NComps_Cols() const;
+
+  protected:
+    /**@name Methods overloaded from Matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    virtual void TransMultVectorImpl(Number alpha, const Vector& x,
+                                     Number beta, Vector& y) const;
+
+    /** X = beta*X + alpha*(Matrix S^{-1} Z).  Specialized implementation.
+     */
+    virtual void AddMSinvZImpl(Number alpha, const Vector& S, const Vector& Z,
+                               Vector& X) const;
+
+    /** X = S^{-1} (r + alpha*Z*M^Td).  Specialized implementation.
+     */
+    virtual void SinvBlrmZMTdBrImpl(Number alpha, const Vector& S,
+                                    const Vector& R, const Vector& Z,
+                                    const Vector& D, Vector& X) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    CompoundMatrix();
+
+    /** Copy Constructor */
+    CompoundMatrix(const CompoundMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const CompoundMatrix&);
+    //@}
+
+    /** Matrix of matrix's containing the components */
+    std::vector<std::vector<SmartPtr<Matrix> > > comps_;
+
+    /** Matrix of const matrix's containing the components */
+    std::vector<std::vector<SmartPtr<const Matrix> > > const_comps_;
+
+    /** Copy of the owner_space ptr as a CompoundMatrixSpace instead
+     *  of MatrixSpace */
+    const CompoundMatrixSpace* owner_space_;
+
+    /** boolean indicating if the compound matrix is in a "valid" state */
+    mutable bool matrices_valid_;
+
+    /** Method to check whether or not the matrices are valid */
+    bool MatricesValid() const;
+
+    inline const Matrix* ConstComp(Index irow, Index jcol) const;
+
+    inline Matrix* Comp(Index irow, Index jcol);
+  };
+
+  /** This is the matrix space for CompoundMatrix.  Before a CompoundMatrix
+   *  can be created, at least one MatrixSpace has to be set per block
+   *  row and column.  Individual component MatrixSpace's can be set
+   *  with the SetComp method.
+   */
+  class CompoundMatrixSpace : public MatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of row and columns blocks, as
+     *  well as the totel number of rows and columns.
+     */
+    CompoundMatrixSpace(Index ncomps_rows,
+                        Index ncomps_cols,
+                        Index total_nRows,
+                        Index total_nCols);
+
+    /** Destructor */
+    ~CompoundMatrixSpace()
+    {}
+    //@}
+
+    /** @name Methods for setting information about the components. */
+    //@{
+    /** Set the number nrows of rows in row-block number irow. */
+    void SetBlockRows(Index irow, Index nrows);
+
+    /** Set the number ncols of columns in column-block number jcol. */
+    void SetBlockCols(Index jcol, Index ncols);
+
+    /** Get the number nrows of rows in row-block number irow. */
+    Index GetBlockRows(Index irow) const;
+
+    /** Set the number ncols of columns in column-block number jcol. */
+    Index GetBlockCols(Index jcol) const;
+
+    /** Set the component MatrixSpace.  If auto_allocate is true, then
+     *  a new CompoundMatrix created later with MakeNew will have this
+     *  component automatically created with the Matrix's MakeNew.
+     *  Otherwise, the corresponding component will be NULL and has to
+     *  be set with the SetComp methods of the CompoundMatrix.
+     */
+    void SetCompSpace(Index irow, Index jcol,
+                      const MatrixSpace& mat_space,
+                      bool auto_allocate = false);
+    //@}
+
+    /** Obtain the component MatrixSpace in block row irow and block
+     *  column jcol.
+     */
+    SmartPtr<const MatrixSpace> GetCompSpace(Index irow, Index jcol) const
+    {
+      DBG_ASSERT(irow<NComps_Rows());
+      DBG_ASSERT(jcol<NComps_Cols());
+      return comp_spaces_[irow][jcol];
+    }
+
+    /** @name Accessor methods */
+    //@{
+    /** Number of block rows */
+    Index NComps_Rows() const
+    {
+      return ncomps_rows_;
+    }
+    /** Number of block columns */
+    Index NComps_Cols() const
+    {
+      return ncomps_cols_;
+    }
+
+    /** True if the blocks lie on the diagonal - can make some operations faster */
+    bool Diagonal() const
+    {
+      return diagonal_;
+    }
+    //@}
+
+    /** Method for creating a new matrix of this specific type. */
+    CompoundMatrix* MakeNewCompoundMatrix() const;
+
+    /** Overloaded MakeNew method for the MatrixSpace base class.
+     */
+    virtual Matrix* MakeNew() const
+    {
+      return MakeNewCompoundMatrix();
+    }
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default constructor */
+    CompoundMatrixSpace();
+
+    /** Copy Constructor */
+    CompoundMatrixSpace(const CompoundMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    CompoundMatrixSpace& operator=(const CompoundMatrixSpace&);
+    //@}
+
+    /** Number of block rows */
+    Index ncomps_rows_;
+
+    /** Number of block columns */
+    Index ncomps_cols_;
+
+    /** Store whether or not the dimensions are valid */
+    mutable bool dimensions_set_;
+
+    /** 2-dim std::vector of matrix spaces for the components */
+    std::vector<std::vector<SmartPtr<const MatrixSpace> > > comp_spaces_;
+
+    /** 2-dim std::vector of booleans deciding whether to
+     *  allocate a new matrix for the blocks automagically */
+    std::vector<std::vector< bool > > allocate_block_;
+
+    /** Vector of the number of rows in each comp column */
+    std::vector<Index> block_rows_;
+
+    /** Vector of the number of cols in each comp row */
+    std::vector<Index> block_cols_;
+
+    /** true if the CompoundMatrixSpace only has Matrix spaces along the diagonal.
+     *  this means that the CompoundMatrix will only have matrices along the 
+     *  diagonal and it could make some operations more efficient
+     */
+    bool diagonal_;
+
+    /** Auxilliary function for debugging to set if all block
+     *  dimensions have been set. */
+    bool DimensionsSet() const;
+  };
+
+  /* inline methods */
+  inline
+  Index CompoundMatrix::NComps_Rows() const
+  {
+    return owner_space_->NComps_Rows();
+  }
+
+  inline
+  Index CompoundMatrix::NComps_Cols() const
+  {
+    return owner_space_->NComps_Cols();
+  }
+
+  inline
+  const Matrix* CompoundMatrix::ConstComp(Index irow, Index jcol) const
+  {
+    DBG_ASSERT(irow < NComps_Rows());
+    DBG_ASSERT(jcol < NComps_Cols());
+    if (IsValid(comps_[irow][jcol])) {
+      return GetRawPtr(comps_[irow][jcol]);
+    }
+    else if (IsValid(const_comps_[irow][jcol])) {
+      return GetRawPtr(const_comps_[irow][jcol]);
+    }
+
+    return NULL;
+  }
+
+  inline
+  Matrix* CompoundMatrix::Comp(Index irow, Index jcol)
+  {
+    DBG_ASSERT(irow < NComps_Rows());
+    DBG_ASSERT(jcol < NComps_Cols());
+    return GetRawPtr(comps_[irow][jcol]);
+  }
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpCompoundSymMatrix.hpp b/thirdparty/linux/include/coin/IpCompoundSymMatrix.hpp
new file mode 100644
index 0000000..4ca18fe
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpCompoundSymMatrix.hpp
@@ -0,0 +1,283 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpCompoundSymMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPCOMPOUNDSYMMATRIX_HPP__
+#define __IPCOMPOUNDSYMMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class CompoundSymMatrixSpace;
+
+  /** Class for symmetric matrices consisting of other matrices.
+   *  Here, the lower left block of the matrix is stored.
+   */
+  class CompoundSymMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking only the number for block components into the
+     *  row and column direction.  The owner_space has to be defined, so
+     *  that at each block row and column contain at least one non-NULL
+     *  component.
+     */
+    CompoundSymMatrix(const CompoundSymMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~CompoundSymMatrix();
+    //@}
+
+    /** Method for setting an individual component at position (irow,
+     *  icol) in the compound matrix.  The counting of indices starts
+     *  at 0. Since this only the lower left components are stored, we need
+     *  to have jcol<=irow, and if irow==jcol, the matrix must be a SymMatrix */
+    void SetComp(Index irow, Index jcol, const Matrix& matrix);
+
+    /** Non const version of the same method */
+    void SetCompNonConst(Index irow, Index jcol, Matrix& matrix);
+
+    /** Method for retrieving one block from the compound matrix.
+     *  Since this only the lower left components are stored, we need
+     *  to have jcol<=irow */
+    SmartPtr<const Matrix> GetComp(Index irow, Index jcol) const
+    {
+      return ConstComp(irow,jcol);
+    }
+
+    /** Non const version of GetComp.  You should only use this method
+     *  if you are intending to change the matrix you receive, since
+     *  this CompoundSymMatrix will be marked as changed. */
+    SmartPtr<Matrix> GetCompNonConst(Index irow, Index jcol)
+    {
+      ObjectChanged();
+      return Comp(irow,jcol);
+    }
+
+    /** Method for creating a new matrix of this specific type. */
+    SmartPtr<CompoundSymMatrix> MakeNewCompoundSymMatrix() const;
+
+    // The following don't seem to be necessary
+    /* Number of block rows of this compound matrix. */
+    //    Index NComps_NRows() const { return NComps_Dim(); }
+
+    /* Number of block colmuns of this compound matrix. */
+    //    Index NComps_NCols() const { return NComps_Dim(); }
+
+    /** Number of block rows and columns */
+    Index NComps_Dim() const;
+
+  protected:
+    /**@name Methods overloaded from matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    CompoundSymMatrix();
+
+    /** Copy Constructor */
+    CompoundSymMatrix(const CompoundSymMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const CompoundSymMatrix&);
+    //@}
+
+    /** Vector of vectors containing the components */
+    std::vector<std::vector<SmartPtr<Matrix> > > comps_;
+
+    /** Vector of vectors containing the const components */
+    std::vector<std::vector<SmartPtr<const Matrix> > > const_comps_;
+
+    /** Copy of the owner_space ptr as a CompoundSymMatrixSpace */
+    const CompoundSymMatrixSpace* owner_space_;
+
+    /** boolean indicating if the compound matrix is in a "valid" state */
+    mutable bool matrices_valid_;
+
+    /** method to check wether or not the matrices are valid */
+    bool MatricesValid() const;
+
+    /** Internal method to return a const pointer to one of the comps */
+    const Matrix* ConstComp(Index irow, Index jcol) const
+    {
+      DBG_ASSERT(irow < NComps_Dim());
+      DBG_ASSERT(jcol <= irow);
+      if (IsValid(comps_[irow][jcol])) {
+        return GetRawPtr(comps_[irow][jcol]);
+      }
+      else if (IsValid(const_comps_[irow][jcol])) {
+        return GetRawPtr(const_comps_[irow][jcol]);
+      }
+
+      return NULL;
+    }
+
+    /** Internal method to return a non-const pointer to one of the comps */
+    Matrix* Comp(Index irow, Index jcol)
+    {
+      DBG_ASSERT(irow < NComps_Dim());
+      DBG_ASSERT(jcol <= irow);
+      // We shouldn't be asking for a non-const if this entry holds a
+      // const one...
+      DBG_ASSERT(IsNull(const_comps_[irow][jcol]));
+      if (IsValid(comps_[irow][jcol])) {
+        return GetRawPtr(comps_[irow][jcol]);
+      }
+
+      return NULL;
+    }
+  };
+
+  /** This is the matrix space for CompoundSymMatrix.  Before a
+   *  CompoundSymMatrix can be created, at least one SymMatrixSpace has
+   *  to be set per block row and column.  Individual component
+   *  SymMatrixSpace's can be set with the SetComp method.
+   */
+  class CompoundSymMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of blocks (same for rows and
+     *  columns), as well as the total dimension of the matrix.
+     */
+    CompoundSymMatrixSpace(Index ncomp_spaces, Index total_dim);
+
+    /** Destructor */
+    ~CompoundSymMatrixSpace()
+    {}
+    //@}
+
+    /** @name Methods for setting information about the components. */
+    //@{
+    /** Set the dimension dim for block row (or column) irow_jcol */
+    void SetBlockDim(Index irow_jcol, Index dim);
+
+    /** Get the dimension dim for block row (or column) irow_jcol */
+    Index GetBlockDim(Index irow_jcol) const;
+
+    /** Set the component SymMatrixSpace. If auto_allocate is true, then
+     *  a new CompoundSymMatrix created later with MakeNew will have this
+     *  component automatically created with the SymMatrix's MakeNew.
+     *  Otherwise, the corresponding component will be NULL and has to
+     *  be set with the SetComp methods of the CompoundSymMatrix.
+     */
+    void SetCompSpace(Index irow, Index jcol,
+                      const MatrixSpace& mat_space,
+                      bool auto_allocate = false);
+    //@}
+
+    /** Obtain the component MatrixSpace in block row irow and block
+     *  column jcol.
+     */
+    SmartPtr<const MatrixSpace> GetCompSpace(Index irow, Index jcol) const
+    {
+      DBG_ASSERT(irow<ncomp_spaces_);
+      DBG_ASSERT(jcol<=irow);
+      return comp_spaces_[irow][jcol];
+    }
+
+    /** @name Accessor methods */
+    //@{
+    Index NComps_Dim() const
+    {
+      return ncomp_spaces_;
+    }
+    //@}
+
+    /** Method for creating a new matrix of this specific type. */
+    CompoundSymMatrix* MakeNewCompoundSymMatrix() const;
+
+    /** Overloaded MakeNew method for the SymMatrixSpace base class.
+     */
+    virtual SymMatrix* MakeNewSymMatrix() const
+    {
+      return MakeNewCompoundSymMatrix();
+    }
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default constructor */
+    CompoundSymMatrixSpace();
+
+    /** Copy Constructor */
+    CompoundSymMatrixSpace(const CompoundSymMatrix&);
+
+    /** Overloaded Equals Operator */
+    CompoundSymMatrixSpace& operator=(const CompoundSymMatrixSpace&);
+    //@}
+
+    /** Number of components per row and column */
+    Index ncomp_spaces_;
+
+    /** Vector of the number of rows in each comp column,
+     *  Since this is symmetric, this is also the number
+     *  of columns in each row, hence, it is the dimension
+     *  each of the diagonals */
+    std::vector<Index> block_dim_;
+
+    /** 2-dim std::vector of matrix spaces for the components.  Only
+     *  the lower right part is stored. */
+    std::vector<std::vector<SmartPtr<const MatrixSpace> > > comp_spaces_;
+
+    /** 2-dim std::vector of booleans deciding whether to
+     *  allocate a new matrix for the blocks automagically */
+    std::vector<std::vector< bool > > allocate_block_;
+
+    /** boolean indicating if the compound matrix space is in a "valid" state */
+    mutable bool dimensions_set_;
+
+    /** Method to check whether or not the spaces are valid */
+    bool DimensionsSet() const;
+  };
+
+  inline
+  SmartPtr<CompoundSymMatrix> CompoundSymMatrix::MakeNewCompoundSymMatrix() const
+  {
+    return owner_space_->MakeNewCompoundSymMatrix();
+  }
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpConvCheck.hpp b/thirdparty/linux/include/coin/IpConvCheck.hpp
new file mode 100644
index 0000000..033fce4
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpConvCheck.hpp
@@ -0,0 +1,87 @@
+// Copyright (C) 2004, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpConvCheck.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPCONVCHECK_HPP__
+#define __IPCONVCHECK_HPP__
+
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+
+  /** Base class for checking the algorithm
+   *  termination criteria.
+   */
+  class ConvergenceCheck : public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Constructor */
+    ConvergenceCheck()
+    {}
+
+    /** Default destructor */
+    virtual ~ConvergenceCheck()
+    {}
+    //@}
+
+    /** Convergence return enum */
+    enum ConvergenceStatus {
+      CONTINUE,
+      CONVERGED,
+      CONVERGED_TO_ACCEPTABLE_POINT,
+      MAXITER_EXCEEDED,
+      CPUTIME_EXCEEDED,
+      DIVERGING,
+      USER_STOP,
+      FAILED
+    };
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Pure virtual method for performing the convergence test.  If
+     *  call_intermediate_callback is true, the user callback method
+     *  in the NLP should be called in order to see if the user
+     *  requests an early termination. */
+    virtual ConvergenceStatus
+    CheckConvergence(bool call_intermediate_callback = true) = 0;
+
+    /** Method for testing if the current iterate is considered to
+     *  satisfy the "accptable level" of accuracy.  The idea is that
+     *  if the desired convergence tolerance cannot be achieved, the
+     *  algorithm might stop after a number of acceptable points have
+     *  been encountered. */
+    virtual bool CurrentIsAcceptable()=0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    //    ConvergenceCheck();
+
+    /** Copy Constructor */
+    ConvergenceCheck(const ConvergenceCheck&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const ConvergenceCheck&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpDiagMatrix.hpp b/thirdparty/linux/include/coin/IpDiagMatrix.hpp
new file mode 100644
index 0000000..d912e77
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpDiagMatrix.hpp
@@ -0,0 +1,141 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpDiagMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPDIAGMATRIX_HPP__
+#define __IPDIAGMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /** Class for diagonal matrices.  The diagonal is stored as a
+   *  Vector. */
+  class DiagMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, given the corresponding matrix space. */
+    DiagMatrix(const SymMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~DiagMatrix();
+    //@}
+
+    /** Method for setting the diagonal elements (as a Vector). */
+    void SetDiag(const Vector& diag)
+    {
+      diag_ = &diag;
+    }
+
+    /** Method for setting the diagonal elements. */
+    SmartPtr<const Vector> GetDiag() const
+    {
+      return diag_;
+    }
+
+  protected:
+    /**@name Methods overloaded from matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    DiagMatrix();
+
+    /** Copy Constructor */
+    DiagMatrix(const DiagMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const DiagMatrix&);
+    //@}
+
+    /** Vector storing the diagonal elements */
+    SmartPtr<const Vector> diag_;
+  };
+
+  /** This is the matrix space for DiagMatrix. */
+  class DiagMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the dimension of the matrix. */
+    DiagMatrixSpace(Index dim)
+        :
+        SymMatrixSpace(dim)
+    {}
+
+    /** Destructor */
+    virtual ~DiagMatrixSpace()
+    {}
+    //@}
+
+    /** Overloaded MakeNew method for the SymMatrixSpace base class.
+     */
+    virtual SymMatrix* MakeNewSymMatrix() const
+    {
+      return MakeNewDiagMatrix();
+    }
+
+    /** Method for creating a new matrix of this specific type. */
+    DiagMatrix* MakeNewDiagMatrix() const
+    {
+      return new DiagMatrix(this);
+    }
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    DiagMatrixSpace();
+
+    /** Copy Constructor */
+    DiagMatrixSpace(const DiagMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const DiagMatrixSpace&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpEqMultCalculator.hpp b/thirdparty/linux/include/coin/IpEqMultCalculator.hpp
new file mode 100644
index 0000000..7c3cb20
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpEqMultCalculator.hpp
@@ -0,0 +1,64 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpEqMultCalculator.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter              IBM    2004-09-23
+
+#ifndef __IPEQMULTCALCULATOR_HPP__
+#define __IPEQMULTCALCULATOR_HPP__
+
+#include "IpUtils.hpp"
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+  /** Base Class for objects that compute estimates for the equality
+   *  constraint multipliers y_c and y_d.  For example, this is the
+   *  base class for objects for computing least square multipliers or
+   *  coordinate multipliers. */
+  class EqMultiplierCalculator: public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor. */
+    EqMultiplierCalculator()
+    {}
+    /** Default destructor */
+    virtual ~EqMultiplierCalculator()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** This method computes the estimates for y_c and y_d at the
+     *  current point.  If the estimates cannot be computed (e.g. some
+     *  linear system is singular), the return value of this method is
+     *  false. */
+    virtual bool CalculateMultipliers(Vector& y_c,
+                                      Vector& y_d) = 0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Copy Constructor */
+    EqMultiplierCalculator(const EqMultiplierCalculator&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const EqMultiplierCalculator&);
+    //@}
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpGenTMatrix.hpp b/thirdparty/linux/include/coin/IpGenTMatrix.hpp
new file mode 100644
index 0000000..059bfea
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpGenTMatrix.hpp
@@ -0,0 +1,264 @@
+// Copyright (C) 2004, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpGenTMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPGENTMATRIX_HPP__
+#define __IPGENTMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class GenTMatrixSpace;
+
+  /** Class for general matrices stored in triplet format.  In the
+   *  triplet format, the nonzeros elements of a general matrix is
+   *  stored in three arrays, Irow, Jcol, and Values, all of length
+   *  Nonzeros.  The first two arrays indicate the location of a
+   *  non-zero element (row and column indices), and the last array
+   *  stores the value at that location.  If nonzero elements are
+   *  listed more than once, their values are added.
+   *
+   *  The structure of the nonzeros (i.e. the arrays Irow and Jcol)
+   *  cannot be changed after the matrix can been initialized.  Only
+   *  the values of the nonzero elements can be modified.
+   *
+   *  Note that the first row and column of a matrix has index 1, not
+   *  0.
+   */
+  class GenTMatrix : public Matrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the owner_space.
+     */
+    GenTMatrix(const GenTMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~GenTMatrix();
+    //@}
+
+    /**@name Changing the Values.*/
+    //@{
+    /** Set values of nonzero elements.  The values of the nonzero
+     *  elements are copied from the incoming Number array.  Important:
+     *  It is assume that the order of the values in Values
+     *  corresponds to the one of Irn and Jcn given to one of the
+     *  constructors above. */
+    void SetValues(const Number* Values);
+    //@}
+
+    /** @name Accessor Methods */
+    //@{
+    /** Number of nonzero entries */
+    Index Nonzeros() const;
+
+    /** Array with Row indices (counting starts at 1) */
+    const Index* Irows() const;
+
+    /** Array with Column indices (counting starts at 1) */
+    const Index* Jcols() const;
+
+    /** Array with nonzero values (const version).  */
+    const Number* Values() const
+    {
+      return values_;
+    }
+
+    /** Array with the nonzero values of this matrix (non-const
+     *  version).  Use this method only if you are intending to change
+     *  the values, because the GenTMatrix will be marked as changed.
+     */
+    Number* Values()
+    {
+      ObjectChanged();
+      initialized_ = true;
+      return values_;
+    }
+    //@}
+
+  protected:
+    /**@name Overloaded methods from Matrix base class*/
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector &x, Number beta,
+                                Vector &y) const;
+
+    virtual void TransMultVectorImpl(Number alpha, const Vector& x, Number beta,
+                                     Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const
+    {
+      PrintImplOffset(jnlst, level, category, name, indent, prefix, 0);
+    }
+    //@}
+
+    void PrintImplOffset(const Journalist& jnlst,
+                         EJournalLevel level,
+                         EJournalCategory category,
+                         const std::string& name,
+                         Index indent,
+                         const std::string& prefix,
+                         Index offset) const;
+
+    friend class ParGenMatrix;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    GenTMatrix();
+
+    /** Copy Constructor */
+    GenTMatrix(const GenTMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const GenTMatrix&);
+    //@}
+
+    /** Copy of the owner space as a GenTMatrixSpace instead of
+     *  a MatrixSpace
+     */
+    const GenTMatrixSpace* owner_space_;
+
+    /** Values of nonzeros */
+    Number* values_;
+
+    /** Flag for Initialization */
+    bool initialized_;
+
+  };
+
+  /** This is the matrix space for a GenTMatrix with fixed sparsity
+   *  structure.  The sparsity structure is stored here in the matrix
+   *  space.
+   */
+  class GenTMatrixSpace : public MatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of rows and columns, as well as
+     *  the number of nonzeros and the position of the nonzero
+     *  elements.  Note that the counting of the nonzeros starts a 1,
+     *  i.e., iRows[i]==1 and jCols[i]==1 refers to the first element
+     *  in the first row.  This is in accordance with the HSL data
+     *  structure.
+     */
+    GenTMatrixSpace(Index nRows, Index nCols,
+                    Index nonZeros,
+                    const Index* iRows, const Index* jCols);
+
+    /** Destructor */
+    ~GenTMatrixSpace()
+    {
+      delete [] iRows_;
+      delete [] jCols_;
+    }
+    //@}
+
+    /** Method for creating a new matrix of this specific type. */
+    GenTMatrix* MakeNewGenTMatrix() const
+    {
+      return new GenTMatrix(this);
+    }
+
+    /** Overloaded MakeNew method for the MatrixSpace base class.
+     */
+    virtual Matrix* MakeNew() const
+    {
+      return MakeNewGenTMatrix();
+    }
+
+    /**@name Methods describing Matrix structure */
+    //@{
+    /** Number of non-zeros in the sparse matrix */
+    Index Nonzeros() const
+    {
+      return nonZeros_;
+    }
+
+    /** Row index of each non-zero element (counting starts at 1) */
+    const Index* Irows() const
+    {
+      return iRows_;
+    }
+
+    /** Column index of each non-zero element (counting starts at 1) */
+    const Index* Jcols() const
+    {
+      return jCols_;
+    }
+    //@}
+
+  private:
+    /** @name Sparsity structure of matrices generated by this matrix
+     *  space.
+     */
+    //@{
+    const Index nonZeros_;
+    Index* jCols_;
+    Index* iRows_;
+    //@}
+
+    /** This method is only for the GenTMatrix to call in order
+     *   to allocate internal storage */
+    Number* AllocateInternalStorage() const;
+
+    /** This method is only for the GenTMatrix to call in order
+     *   to de-allocate internal storage */
+    void FreeInternalStorage(Number* values) const;
+
+    friend class GenTMatrix;
+  };
+
+  /* inline methods */
+  inline
+  Index GenTMatrix::Nonzeros() const
+  {
+    return owner_space_->Nonzeros();
+  }
+
+  inline
+  const Index* GenTMatrix::Irows() const
+  {
+    return owner_space_->Irows();
+  }
+
+  inline
+  const Index* GenTMatrix::Jcols() const
+  {
+    return owner_space_->Jcols();
+  }
+
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpHessianUpdater.hpp b/thirdparty/linux/include/coin/IpHessianUpdater.hpp
new file mode 100644
index 0000000..a3912d6
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpHessianUpdater.hpp
@@ -0,0 +1,65 @@
+// Copyright (C) 2005, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpHessianUpdater.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Andreas Waechter            IBM    2005-12-26
+
+#ifndef __IPHESSIANUPDATER_HPP__
+#define __IPHESSIANUPDATER_HPP__
+
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+
+  /** Abstract base class for objects responsible for updating the
+   *  Hessian information.  This can be done using exact second
+   *  derivatives from the NLP, or by a quasi-Newton Option.  The
+   *  result is put into the W field in IpData.
+   */
+  class HessianUpdater : public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    HessianUpdater()
+    {}
+
+    /** Default destructor */
+    virtual ~HessianUpdater()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Update the Hessian based on the current information in IpData,
+     *  and possibly on information from previous calls.
+     */
+    virtual void UpdateHessian() = 0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Copy Constructor */
+    HessianUpdater(const HessianUpdater&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const HessianUpdater&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpIdentityMatrix.hpp b/thirdparty/linux/include/coin/IpIdentityMatrix.hpp
new file mode 100644
index 0000000..8032306
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpIdentityMatrix.hpp
@@ -0,0 +1,149 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpIdentityMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPIDENTITYMATRIX_HPP__
+#define __IPIDENTITYMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /** Class for Matrices which are multiples of the identity matrix.
+   *
+   */
+  class IdentityMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, initializing with dimensions of the matrix
+     *  (true identity matrix).
+     */
+    IdentityMatrix(const SymMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~IdentityMatrix();
+    //@}
+
+    /** Method for setting the factor for the identity matrix. */
+    void SetFactor(Number factor)
+    {
+      factor_ = factor;
+    }
+
+    /** Method for getting the factor for the identity matrix. */
+    Number GetFactor() const
+    {
+      return factor_;
+    }
+
+    /** Method for obtaining the dimention of the matrix. */
+    Index Dim() const;
+
+  protected:
+    /**@name Methods overloaded from matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    virtual void AddMSinvZImpl(Number alpha, const Vector& S,
+                               const Vector& Z, Vector& X) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    IdentityMatrix();
+
+    /** Copy Constructor */
+    IdentityMatrix(const IdentityMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const IdentityMatrix&);
+    //@}
+
+    /** Scaling factor for this identity matrix */
+    Number factor_;
+  };
+
+  /** This is the matrix space for IdentityMatrix. */
+  class IdentityMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the dimension of the matrix. */
+    IdentityMatrixSpace(Index dim)
+        :
+        SymMatrixSpace(dim)
+    {}
+
+    /** Destructor */
+    virtual ~IdentityMatrixSpace()
+    {}
+    //@}
+
+    /** Overloaded MakeNew method for the SymMatrixSpace base class.
+     */
+    virtual SymMatrix* MakeNewSymMatrix() const
+    {
+      return MakeNewIdentityMatrix();
+    }
+
+    /** Method for creating a new matrix of this specific type. */
+    IdentityMatrix* MakeNewIdentityMatrix() const
+    {
+      return new IdentityMatrix(this);
+    }
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    IdentityMatrixSpace();
+
+    /** Copy Constructor */
+    IdentityMatrixSpace(const IdentityMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const IdentityMatrixSpace&);
+    //@}
+  };
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpIpoptAlg.hpp b/thirdparty/linux/include/coin/IpIpoptAlg.hpp
new file mode 100644
index 0000000..60e3147
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpIpoptAlg.hpp
@@ -0,0 +1,224 @@
+// Copyright (C) 2004, 2010 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpIpoptAlg.hpp 2167 2013-03-08 11:15:38Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPIPOPTALG_HPP__
+#define __IPIPOPTALG_HPP__
+
+#include "IpIpoptNLP.hpp"
+#include "IpAlgStrategy.hpp"
+#include "IpSearchDirCalculator.hpp"
+#include "IpLineSearch.hpp"
+#include "IpMuUpdate.hpp"
+#include "IpConvCheck.hpp"
+#include "IpOptionsList.hpp"
+#include "IpIterateInitializer.hpp"
+#include "IpIterationOutput.hpp"
+#include "IpAlgTypes.hpp"
+#include "IpHessianUpdater.hpp"
+#include "IpEqMultCalculator.hpp"
+
+namespace Ipopt
+{
+
+  /** @name Exceptions */
+  //@{
+  DECLARE_STD_EXCEPTION(STEP_COMPUTATION_FAILED);
+  //@}
+
+  /** The main ipopt algorithm class.
+   *  Main Ipopt algorithm class, contains the main optimize method,
+   *  handles the execution of the optimization.
+   *  The constructor initializes the data structures through the nlp,
+   *  and the Optimize method then assumes that everything is 
+   *  initialized and ready to go.
+   *  After an optimization is complete, the user can access the 
+   *  solution through the passed in ip_data structure.
+   *  Multiple calls to the Optimize method are allowed as long as the
+   *  structure of the problem remains the same (i.e. starting point
+   *  or nlp parameter changes only).
+   */
+  class IpoptAlgorithm : public AlgorithmStrategyObject
+  {
+  public:
+
+    /**@name Constructors/Destructors */
+    //@{
+    /** Constructor. (The IpoptAlgorithm uses smart pointers for these
+     *  passed-in pieces to make sure that a user of IpoptAlgoroithm
+     *  cannot pass in an object created on the stack!)
+     */
+    IpoptAlgorithm(const SmartPtr<SearchDirectionCalculator>& search_dir_calculator,
+                   const SmartPtr<LineSearch>& line_search,
+                   const SmartPtr<MuUpdate>& mu_update,
+                   const SmartPtr<ConvergenceCheck>& conv_check,
+                   const SmartPtr<IterateInitializer>& iterate_initializer,
+                   const SmartPtr<IterationOutput>& iter_output,
+                   const SmartPtr<HessianUpdater>& hessian_updater,
+                   const SmartPtr<EqMultiplierCalculator>& eq_multiplier_calculator = NULL);
+
+    /** Default destructor */
+    virtual ~IpoptAlgorithm();
+    //@}
+
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix);
+
+    /** Main solve method. */
+    SolverReturn Optimize(bool isResto = false);
+
+    /** Methods for IpoptType */
+    //@{
+    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
+    //@}
+
+    /**@name Access to internal strategy objects */
+    //@{
+    SmartPtr<SearchDirectionCalculator> SearchDirCalc()
+    {
+      return search_dir_calculator_;
+    }
+    //@}
+
+    static void print_copyright_message(const Journalist& jnlst);
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    IpoptAlgorithm();
+
+    /** Copy Constructor */
+    IpoptAlgorithm(const IpoptAlgorithm&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const IpoptAlgorithm&);
+    //@}
+
+    /** @name Strategy objects */
+    //@{
+    SmartPtr<SearchDirectionCalculator> search_dir_calculator_;
+    SmartPtr<LineSearch> line_search_;
+    SmartPtr<MuUpdate> mu_update_;
+    SmartPtr<ConvergenceCheck> conv_check_;
+    SmartPtr<IterateInitializer> iterate_initializer_;
+    SmartPtr<IterationOutput> iter_output_;
+    SmartPtr<HessianUpdater> hessian_updater_;
+    /** The multipler calculator (for y_c and y_d) has to be set only
+     *  if option recalc_y is set to true */
+    SmartPtr<EqMultiplierCalculator> eq_multiplier_calculator_;
+    //@}
+
+    /** @name Main steps of the algorthim */
+    //@{
+    /** Method for updating the current Hessian.  This can either just
+     *  evaluate the exact Hessian (based on the current iterate), or
+     *  perform a quasi-Newton update.
+     */
+    void UpdateHessian();
+
+    /** Method to update the barrier parameter.  Returns false, if the
+     *  algorithm can't continue with the regular procedure and needs
+     *  to revert to a fallback mechanism in the line search (such as
+     *  restoration phase) */
+    bool UpdateBarrierParameter();
+
+    /** Method to setup the call to the PDSystemSolver.  Returns
+     *  false, if the algorithm can't continue with the regular
+     *  procedure and needs to revert to a fallback mechanism in the
+     *  line search (such as restoration phase) */
+    bool ComputeSearchDirection();
+
+    /** Method computing the new iterate (usually vialine search).
+     *  The acceptable point is the one in trial after return.
+     */
+    void ComputeAcceptableTrialPoint();
+
+    /** Method for accepting the trial point as the new iteration,
+     *  possibly after adjusting the variable bounds in the NLP. */
+    void AcceptTrialPoint();
+
+    /** Do all the output for one iteration */
+    void OutputIteration();
+
+    /** Sets up initial values for the iterates,
+     * Corrects the initial values for x and s (force in bounds) 
+     */
+    void InitializeIterates();
+
+    /** Print the problem size statistics */
+    void PrintProblemStatistics();
+
+    /** Compute the Lagrangian multipliers for a feasibility problem*/
+    void ComputeFeasibilityMultipliers();
+    //@}
+
+    /** @name internal flags */
+    //@{
+    /** Flag indicating if the statistic should not be printed */
+    bool skip_print_problem_stats_;
+    //@}
+
+    /** @name Algorithmic parameters */
+    //@{
+    /** safeguard factor for bound multipliers.  If value >= 1, then
+     *  the dual variables will never deviate from the primal estimate
+     *  by more than the factors kappa_sigma and 1./kappa_sigma.
+     */
+    Number kappa_sigma_;
+    /** Flag indicating whether the y multipliers should be
+     *  recalculated with the eq_mutliplier_calculator object for each
+     *  new point. */
+    bool recalc_y_;
+    /** Feasibility threshold for recalc_y */
+    Number recalc_y_feas_tol_;
+    /** Flag indicating if we want to do Mehrotras's algorithm.  This
+     *  means that a number of options are ignored, or have to be set
+     *  (or are automatically set) to certain values. */
+    bool mehrotra_algorithm_;
+    /** String specifying linear solver */
+    std::string linear_solver_;
+    //@}
+
+    /** @name auxiliary functions */
+    //@{
+    void calc_number_of_bounds(
+      const Vector& x,
+      const Vector& x_L,
+      const Vector& x_U,
+      const Matrix& Px_L,
+      const Matrix& Px_U,
+      Index& n_tot,
+      Index& n_only_lower,
+      Index& n_both,
+      Index& n_only_upper);
+
+    /** Method for ensuring that the trial multipliers are not too far
+     *  from the primal estime.  If a correction is made, new_trial_z
+     *  is a pointer to the corrected multiplier, and the return value
+     *  of this method give the magnitutde of the largest correction
+     *  that we done.  If no correction was made, new_trial_z is just
+     *  a pointer to trial_z, and the return value is zero.
+     */
+    Number correct_bound_multiplier(const Vector& trial_z,
+                                    const Vector& trial_slack,
+                                    const Vector& trial_compl,
+                                    SmartPtr<const Vector>& new_trial_z);
+    //@}
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpIpoptApplication.hpp b/thirdparty/linux/include/coin/IpIpoptApplication.hpp
index 5f59292..0febc94 100644
--- a/thirdparty/linux/include/coin/IpIpoptApplication.hpp
+++ b/thirdparty/linux/include/coin/IpIpoptApplication.hpp
@@ -2,7 +2,7 @@
 // All Rights Reserved.
 // This code is published under the Eclipse Public License.
 //
-// $Id: IpIpoptApplication.hpp 2398 2013-10-19 18:08:59Z stefan $
+// $Id: IpIpoptApplication.hpp 2617 2015-11-26 16:00:20Z stefan $
 //
 // Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
@@ -69,8 +69,10 @@ namespace Ipopt
      *  problem in the initialization (such as an invalid option).
      *  You should call one of the initialization methods at some
      *  point before the first optimize call.
+     *  Set @par allow_clobber to true if you want to allow
+     *  overwriting options that are set by the input stream.
      */
-    virtual ApplicationReturnStatus Initialize(std::istream& is);
+    virtual ApplicationReturnStatus Initialize(std::istream& is, bool allow_clobber = false);
     /** Initialization method. This method reads options from the
      *  params file and initializes the journalists. It returns
      *  something other than Solve_Succeeded if there was a
@@ -79,16 +81,35 @@ namespace Ipopt
      *  point before the first optimize call.
      *  Note: You can skip the processing of a params file by
      *  setting params_file to "".
+     *  Set @par allow_clobber to true if you want to allow
+     *  overwriting options that are set by the params file.
      */
-    virtual ApplicationReturnStatus Initialize(std::string params_file);
+    virtual ApplicationReturnStatus Initialize(std::string params_file, bool allow_clobber = false);
+    /** Initialization method. This method reads options from the
+     *  params file and initializes the journalists. It returns
+     *  something other than Solve_Succeeded if there was a
+     *  problem in the initialization (such as an invalid option).
+     *  You should call one of the initialization methods at some
+     *  point before the first optimize call.
+     *  Note: You can skip the processing of a params file by
+     *  setting params_file to "".
+     *  Set @par allow_clobber to true if you want to allow
+     *  overwriting options that are set by the params file.
+     */
+    virtual ApplicationReturnStatus Initialize(const char* params_file, bool allow_clobber = false)
+    {
+       return Initialize(std::string(params_file), allow_clobber);
+    }
     /** Initialize method. This method reads the options file specified
      *  by the option_file_name option and initializes the journalists.
      *  You should call this method at some point before the first optimize
      *  call.
      *  It returns something other than Solve_Succeeded if there was a
      *  problem in the initialization (such as an invalid option).
+     *  Set @par allow_clobber to true if you want to allow
+     *  overwriting options that are set by the options file.
      */
-    virtual ApplicationReturnStatus Initialize();
+    virtual ApplicationReturnStatus Initialize(bool allow_clobber = false);
 
     /**@name Solve methods */
     //@{
diff --git a/thirdparty/linux/include/coin/IpIterateInitializer.hpp b/thirdparty/linux/include/coin/IpIterateInitializer.hpp
new file mode 100644
index 0000000..d179651
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpIterateInitializer.hpp
@@ -0,0 +1,64 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpIterateInitializer.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter              IBM    2004-09-24
+
+#ifndef __IPITERATEINITIALIZER_HPP__
+#define __IPITERATEINITIALIZER_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "IpIpoptNLP.hpp"
+#include "IpIpoptData.hpp"
+#include "IpIpoptCalculatedQuantities.hpp"
+
+namespace Ipopt
+{
+
+  /** Base class for all methods for initializing the iterates.
+   */
+  class IterateInitializer: public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    IterateInitializer()
+    {}
+
+    /** Default destructor */
+    virtual ~IterateInitializer()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Compute the initial iterates and set the into the curr field
+     *  of the ip_data object. */
+    virtual bool SetInitialIterates() = 0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Copy Constructor */
+    IterateInitializer(const IterateInitializer&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const IterateInitializer&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpIterationOutput.hpp b/thirdparty/linux/include/coin/IpIterationOutput.hpp
new file mode 100644
index 0000000..95fd650
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpIterationOutput.hpp
@@ -0,0 +1,71 @@
+// Copyright (C) 2004, 2011 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpIterationOutput.hpp 2020 2011-06-16 20:46:16Z andreasw $
+//
+// Authors:  Andreas Waechter, Carl Laird       IBM    2004-09-27
+
+#ifndef __IPITERATIONOUTPUT_HPP__
+#define __IPITERATIONOUTPUT_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "IpIpoptNLP.hpp"
+#include "IpIpoptData.hpp"
+#include "IpIpoptCalculatedQuantities.hpp"
+
+namespace Ipopt
+{
+
+  /** Base class for objects that do the output summary per iteration.
+   */
+  class IterationOutput: public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    IterationOutput()
+    {}
+
+    /** Default destructor */
+    virtual ~IterationOutput()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Method to do all the summary output per iteration.  This
+     *  include the one-line summary output as well as writing the
+     *  details about the iterates if desired */
+    virtual void WriteOutput() = 0;
+
+  protected:
+    /** enumeration for different inf_pr output options */
+    enum InfPrOutput
+    {
+      INTERNAL=0,
+      ORIGINAL
+    };
+
+  private:
+    /**@name Default Compiler Generated Methods (Hidden to avoid
+     * implicit creation/calling).  These methods are not implemented
+     * and we do not want the compiler to implement them for us, so we
+     * declare them private and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Copy Constructor */
+    IterationOutput(const IterationOutput&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const IterationOutput&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpLineSearch.hpp b/thirdparty/linux/include/coin/IpLineSearch.hpp
new file mode 100644
index 0000000..70c11f1
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpLineSearch.hpp
@@ -0,0 +1,96 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpLineSearch.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPLINESEARCH_HPP__
+#define __IPLINESEARCH_HPP__
+
+#include "IpAlgStrategy.hpp"
+#include "IpIpoptCalculatedQuantities.hpp"
+
+namespace Ipopt
+{
+
+  /** Base class for line search objects.
+   */
+  class LineSearch : public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    LineSearch()
+    {}
+
+    /** Default destructor */
+    virtual ~LineSearch()
+    {}
+    //@}
+
+    /** Perform the line search.  As search direction the delta
+     *  in the data object is used
+     */
+    virtual void FindAcceptableTrialPoint() = 0;
+
+    /** Reset the line search.
+     *  This function should be called if all previous information
+     *  should be discarded when the line search is performed the
+     *  next time.  For example, this method should be called after
+     *  the barrier parameter is changed.
+     */
+    virtual void Reset() = 0;
+
+    /** Set flag indicating whether a very rigorous line search should
+     *  be performed.  If this flag is set to true, the line search
+     *  algorithm might decide to abort the line search and not to
+     *  accept a new iterate.  If the line search decided not to
+     *  accept a new iterate, the return value of
+     *  CheckSkippedLineSearch() is true at the next call.  For
+     *  example, in the non-monotone barrier parameter update
+     *  procedure, the filter algorithm should not switch to the
+     *  restoration phase in the free mode; instead, the algorithm
+     *  should swtich to the fixed mode.
+     */
+    virtual void SetRigorousLineSearch(bool rigorous) = 0;
+
+    /** Check if the line search procedure didn't accept a new iterate
+     *  during the last call of FindAcceptableTrialPoint().
+     *  
+     */
+    virtual bool CheckSkippedLineSearch() = 0;
+
+    /** This method should be called if the optimization process
+     *  requires the line search object to switch to some fallback
+     *  mechanism (like the restoration phase), when the regular
+     *  optimization procedure cannot be continued (for example,
+     *  because the search direction could not be computed).  This
+     *  will cause the line search object to immediately proceed with
+     *  this mechanism when FindAcceptableTrialPoint() is call.  This
+     *  method returns false if no fallback mechanism is available. */
+    virtual bool ActivateFallbackMechanism() = 0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Copy Constructor */
+    LineSearch(const LineSearch&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const LineSearch&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpMuUpdate.hpp b/thirdparty/linux/include/coin/IpMuUpdate.hpp
new file mode 100644
index 0000000..b6c1d9c
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpMuUpdate.hpp
@@ -0,0 +1,69 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpMuUpdate.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPMUUPDATE_HPP__
+#define __IPMUUPDATE_HPP__
+
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+  /** Abstract Base Class for classes that implement methods for computing
+   *  the barrier and fraction-to-the-boundary rule parameter for the
+   *  current iteration.
+   */
+  class MuUpdate : public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Default Constructor */
+    MuUpdate()
+    {}
+
+    /** Default destructor */
+    virtual ~MuUpdate()
+    {}
+    //@}
+
+    /** Initialize method - overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Method for determining the barrier parameter for the next
+     *  iteration.  A LineSearch object is passed, so that this method
+     *  can call the Reset method in the LineSearch object, for
+     *  example when then barrier parameter is changed. This method is
+     *  also responsible for setting the fraction-to-the-boundary
+     *  parameter tau.  This method returns false if the update could
+     *  not be performed and the algorithm should revert to an
+     *  emergency fallback mechanism. */
+    virtual bool UpdateBarrierParameter() = 0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+
+    /** Copy Constructor */
+    MuUpdate(const MuUpdate&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const MuUpdate&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpOptionsList.hpp b/thirdparty/linux/include/coin/IpOptionsList.hpp
index 382428e..a17863f 100644
--- a/thirdparty/linux/include/coin/IpOptionsList.hpp
+++ b/thirdparty/linux/include/coin/IpOptionsList.hpp
@@ -2,7 +2,7 @@
 // All Rights Reserved.
 // This code is published under the Eclipse Public License.
 //
-// $Id: IpOptionsList.hpp 1861 2010-12-21 21:34:47Z andreasw $
+// $Id: IpOptionsList.hpp 2613 2015-11-04 14:42:02Z stefan $
 //
 // Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
@@ -232,7 +232,7 @@ namespace Ipopt
 
     /** Read options from the stream is.  Returns false if
      *  an error was encountered. */
-    virtual bool ReadFromStream(const Journalist& jnlst, std::istream& is);
+    virtual bool ReadFromStream(const Journalist& jnlst, std::istream& is, bool allow_clobber = false);
 
   private:
     /**@name Default Compiler Generated Methods
diff --git a/thirdparty/linux/include/coin/IpPDSystemSolver.hpp b/thirdparty/linux/include/coin/IpPDSystemSolver.hpp
new file mode 100644
index 0000000..b436e67
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpPDSystemSolver.hpp
@@ -0,0 +1,130 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpPDSystemSolver.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPPDSYSTEMSOLVER_HPP__
+#define __IPPDSYSTEMSOLVER_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+#include "IpAlgStrategy.hpp"
+#include "IpIteratesVector.hpp"
+
+namespace Ipopt
+{
+
+  /** Pure Primal Dual System Solver Base Class.
+   *  This is the base class for all derived Primal-Dual System Solver Types.
+   *
+   *  Here, we understand the primal-dual system as the following linear
+   *  system:
+   *
+   *  \f$
+   *  \left[\begin{array}{cccccccc}
+   *  W & 0 & J_c^T & J_d^T & -P^x_L & P^x_U & 0 & 0 \\
+   *  0 & 0 & 0 & -I & 0 & 0 & -P_L^d & P_U^d \\
+   *  J_c & 0 & 0 & 0 & 0 & 0 & 0 & 0\\
+   *  J_d & -I & 0 & 0 & 0 & 0 & 0 & 0\\
+   *  Z_L(P_L^x)^T & 0 & 0 & 0 & Sl^x_L & 0 & 0 & 0\\
+   *  -Z_U(P_U^x)^T & 0 & 0 & 0 & 0 & Sl^x_U & 0 & 0\\
+   *  0 & V_L(P_L^d)^T & 0 & 0 & 0 & 0 & Sl^s_L & 0 \\
+   *  0 & -V_U(P_U^d)^T & 0 & 0 & 0 & 0 & 0 & Sl^s_U \\
+   *  \end{array}\right]
+   *  \left(\begin{array}{c}
+   *  sol_x\\ sol_s\\ sol_c\\ sol_d\\ sol^z_L\\ sol^z_U\\ sol^v_L\\
+   *  sol^v_U
+   *  \end{array}\right) = 
+   *  \left(\begin{array}{c}
+   *  rhs_x\\ rhs_s\\ rhs_c\\ rhs_d\\ rhs^z_L\\ rhs^z_U\\ rhs^v_L\\
+   *  rhs^v_U
+   *  \end{array}\right)
+   *  \f$
+   *
+   *  Here, \f$Sl^x_L = (P^x_L)^T x - x_L\f$, 
+   *  \f$Sl^x_U = x_U - (P^x_U)^T x\f$, \f$Sl^d_L = (P^d_L)^T d(x) - d_L\f$,
+   *  \f$Sl^d_U = d_U - (P^d_U)^T d(x)\f$.  The results returned to the
+   *  caller is \f$res = \alpha * sol + \beta * res\f$.
+   *
+   *  The solution of this linear system (in order to compute the search
+   *  direction of the algorthim) usually requires a considerable amount of
+   *  computation time.  Therefore, it is important to tailor the solution
+   *  of this system to the characteristics of the problem.  The purpose of
+   *  this base class is to provide a generic interface to the algorithm
+   *  that it can use whenever it requires a solution of the above system.
+   *  Particular implementation can then be written to provide the methods
+   *  defined here.
+   *
+   *  It is implicitly assumed here, that the upper left 2 by 2 block
+   *  is possibly modified (implicitly or explicitly) so that its
+   *  projection onto the null space of the overall constraint
+   *  Jacobian \f$\left[\begin{array}{cc}J_c & 0\\J_d &
+   *  -I\end{array}\right]\f$ is positive definite.  This is necessary
+   *  to guarantee certain descent properties of the resulting search
+   *  direction.  For example, in the full space implementation, a
+   *  multiple of the identity might be added to the upper left 2 by 2
+   *  block.
+   *
+   *  Note that the Solve method might be called several times for different
+   *  right hand sides, but with identical data.  Therefore, if possible,
+   *  an implemetation of PDSystem should check whether the incoming data has
+   *  changed, and not redo factorization etc. unless necessary.
+   */
+  class PDSystemSolver: public AlgorithmStrategyObject
+  {
+  public:
+    /** @name /Destructor */
+    //@{
+    /** Default Constructor */
+    PDSystemSolver()
+    {}
+
+    /** Default destructor */
+    virtual ~PDSystemSolver()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Solve the primal dual system, given one right hand side.  If
+     *  the flag allow_inexact is set to true, it is not necessary to
+     *  solve the system to best accuracy; for example, we don't want
+     *  iterative refinement during the computation of the second
+     *  order correction.  On the other hand, if improve_solution is
+     *  true, the solution given in res should be improved (here beta
+     *  has to be zero, and res is assume to be the solution for the
+     *  system using rhs, without the factor alpha...).  THe return
+     *  value is false, if a solution could not be computed (for
+     *  example, when the Hessian regularization parameter becomes too
+     *  large.)
+     */
+    virtual bool Solve(Number alpha,
+                       Number beta,
+                       const IteratesVector& rhs,
+                       IteratesVector& res,
+                       bool allow_inexact=false,
+                       bool improve_solution=false) =0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Overloaded Equals Operator */
+    PDSystemSolver& operator=(const PDSystemSolver&);
+    //@}
+  };
+
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpScaledMatrix.hpp b/thirdparty/linux/include/coin/IpScaledMatrix.hpp
new file mode 100644
index 0000000..c182a05
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpScaledMatrix.hpp
@@ -0,0 +1,254 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpScaledMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPSCALEDMATRIX_HPP__
+#define __IPSCALEDMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class ScaledMatrixSpace;
+
+  /** Class for a Matrix in conjunction with its scaling factors for
+   *  row and column scaling. Operations on the matrix are performed using
+   *  the scaled matrix. You can pull out the pointer to the 
+   *  unscaled matrix for unscaled calculations.
+   */
+  class ScaledMatrix : public Matrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the owner_space.
+     */
+    ScaledMatrix(const ScaledMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~ScaledMatrix();
+    //@}
+
+    /** Set the unscaled matrix */
+    void SetUnscaledMatrix(const SmartPtr<const Matrix> unscaled_matrix);
+
+    /** Set the unscaled matrix in a non-const version */
+    void SetUnscaledMatrixNonConst(const SmartPtr<Matrix>& unscaled_matrix);
+
+    /** Return the unscaled matrix in const form */
+    SmartPtr<const Matrix> GetUnscaledMatrix() const;
+
+    /** Return the unscaled matrix in non-const form */
+    SmartPtr<Matrix> GetUnscaledMatrixNonConst();
+
+    /** return the vector for the row scaling */
+    SmartPtr<const Vector> RowScaling() const;
+
+    /** return the vector for the column scaling */
+    SmartPtr<const Vector> ColumnScaling() const;
+
+  protected:
+    /**@name Methods overloaded from Matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    virtual void TransMultVectorImpl(Number alpha, const Vector& x,
+                                     Number beta, Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan).  It is assumed that the scaling factors are
+     *  valid. */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+
+    /** X = beta*X + alpha*(Matrix S^{-1} Z).  Specialized
+     *  implementation missing so far!
+     */
+    virtual void AddMSinvZImpl(Number alpha, const Vector& S, const Vector& Z,
+                               Vector& X) const;
+
+    /** X = S^{-1} (r + alpha*Z*M^Td).  Specialized implementation
+     *  missing so far!
+     */
+    virtual void SinvBlrmZMTdBrImpl(Number alpha, const Vector& S,
+                                    const Vector& R, const Vector& Z,
+                                    const Vector& D, Vector& X) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    ScaledMatrix();
+
+    /** Copy Constructor */
+    ScaledMatrix(const ScaledMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const ScaledMatrix&);
+    //@}
+
+    /** const version of the unscaled matrix */
+    SmartPtr<const Matrix> matrix_;
+    /** non-const version of the unscaled matrix */
+    SmartPtr<Matrix> nonconst_matrix_;
+
+    /** Matrix space stored as a ScaledMatrixSpace */
+    SmartPtr<const ScaledMatrixSpace> owner_space_;
+  };
+
+  /** This is the matrix space for ScaledMatrix.
+   */
+  class ScaledMatrixSpace : public MatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of row and columns blocks, as
+     *  well as the totel number of rows and columns.
+     */
+    ScaledMatrixSpace(const SmartPtr<const Vector>& row_scaling,
+                      bool row_scaling_reciprocal,
+                      const SmartPtr<const MatrixSpace>& unscaled_matrix_space,
+                      const SmartPtr<const Vector>& column_scaling,
+                      bool column_scaling_reciprocal);
+
+    /** Destructor */
+    ~ScaledMatrixSpace()
+    {}
+    //@}
+
+    /** Method for creating a new matrix of this specific type. */
+    ScaledMatrix* MakeNewScaledMatrix(bool allocate_unscaled_matrix = false) const
+    {
+      ScaledMatrix* ret = new ScaledMatrix(this);
+      if (allocate_unscaled_matrix) {
+        SmartPtr<Matrix> unscaled_matrix = unscaled_matrix_space_->MakeNew();
+        ret->SetUnscaledMatrixNonConst(unscaled_matrix);
+      }
+      return ret;
+    }
+
+    /** Overloaded MakeNew method for the MatrixSpace base class.
+     */
+    virtual Matrix* MakeNew() const
+    {
+      return MakeNewScaledMatrix();
+    }
+
+    /** return the vector for the row scaling */
+    SmartPtr<const Vector> RowScaling() const
+    {
+      return ConstPtr(row_scaling_);
+    }
+
+    /** return the matrix space for the unscaled matrix */
+    SmartPtr<const MatrixSpace> UnscaledMatrixSpace() const
+    {
+      return unscaled_matrix_space_;
+    }
+
+    /** return the vector for the column scaling */
+    SmartPtr<const Vector> ColumnScaling() const
+    {
+      return ConstPtr(column_scaling_);
+    }
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default constructor */
+    ScaledMatrixSpace();
+
+    /** Copy Constructor */
+    ScaledMatrixSpace(const ScaledMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    ScaledMatrixSpace& operator=(const ScaledMatrixSpace&);
+    //@}
+
+    /** Row scaling vector */
+    SmartPtr<Vector> row_scaling_;
+    /** unscaled matrix space */
+    SmartPtr<const MatrixSpace> unscaled_matrix_space_;
+    /** column scaling vector */
+    SmartPtr<Vector> column_scaling_;
+  };
+
+  inline
+  void ScaledMatrix::SetUnscaledMatrix(const SmartPtr<const Matrix> unscaled_matrix)
+  {
+    matrix_ = unscaled_matrix;
+    nonconst_matrix_ = NULL;
+    ObjectChanged();
+  }
+
+  inline
+  void ScaledMatrix::SetUnscaledMatrixNonConst(const SmartPtr<Matrix>& unscaled_matrix)
+  {
+    nonconst_matrix_ = unscaled_matrix;
+    matrix_ = GetRawPtr(unscaled_matrix);
+    ObjectChanged();
+  }
+
+  inline
+  SmartPtr<const Matrix> ScaledMatrix::GetUnscaledMatrix() const
+  {
+    return matrix_;
+  }
+
+  inline
+  SmartPtr<Matrix> ScaledMatrix::GetUnscaledMatrixNonConst()
+  {
+    DBG_ASSERT(IsValid(nonconst_matrix_));
+    ObjectChanged();
+    return nonconst_matrix_;
+  }
+
+  inline
+  SmartPtr<const Vector> ScaledMatrix::RowScaling() const
+  {
+    return ConstPtr(owner_space_->RowScaling());
+  }
+
+  inline
+  SmartPtr<const Vector> ScaledMatrix::ColumnScaling() const
+  {
+    return ConstPtr(owner_space_->ColumnScaling());
+  }
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpSearchDirCalculator.hpp b/thirdparty/linux/include/coin/IpSearchDirCalculator.hpp
new file mode 100644
index 0000000..3425c43
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpSearchDirCalculator.hpp
@@ -0,0 +1,65 @@
+// Copyright (C) 2005, 2007 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpSearchDirCalculator.hpp 1861 2010-12-21 21:34:47Z andreasw $
+//
+// Authors:  Andreas Waechter            IBM    2005-10-13
+
+#ifndef __IPSEARCHDIRCALCULATOR_HPP__
+#define __IPSEARCHDIRCALCULATOR_HPP__
+
+#include "IpAlgStrategy.hpp"
+
+namespace Ipopt
+{
+
+  /** Base class for computing the search direction for the line
+   *  search.
+   */
+  class SearchDirectionCalculator : public AlgorithmStrategyObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    /** Constructor */
+    SearchDirectionCalculator()
+    {}
+
+    /** Default destructor */
+    virtual ~SearchDirectionCalculator()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** Pure virtual method for computing the search direction. The
+     *  computed direction is stored in IpData().delta().*/
+    virtual bool ComputeSearchDirection()=0;
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    //    SearchDirectionCalculator();
+
+    /** Copy Constructor */
+    SearchDirectionCalculator(const SearchDirectionCalculator&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const SearchDirectionCalculator&);
+    //@}
+
+  };
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpSumSymMatrix.hpp b/thirdparty/linux/include/coin/IpSumSymMatrix.hpp
new file mode 100644
index 0000000..42b1168
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpSumSymMatrix.hpp
@@ -0,0 +1,152 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpSumSymMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPSUMSYMMATRIX_HPP__
+#define __IPSUMSYMMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class SumSymMatrixSpace;
+
+  /** Class for Matrices which are sum of symmetric matrices.
+   *  For each term in the we store the matrix and a factor.
+   */
+  class SumSymMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, initializing with dimensions of the matrix and
+     *  the number of terms in the sum.
+     */
+    SumSymMatrix(const SumSymMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~SumSymMatrix();
+    //@}
+
+    /** Method for setting term iterm for the sum.  Note that counting
+     *  of terms starts at 0. */
+    void SetTerm(Index iterm, Number factor, const SymMatrix& matrix);
+
+    /** Method for getting term iterm for the sum.  Note that counting
+     *  of terms starts at 0. */
+    void GetTerm(Index iterm, Number& factor, SmartPtr<const SymMatrix>& matrix) const;
+
+    /** Return the number of terms */
+    Index NTerms() const;
+
+  protected:
+    /**@name Methods overloaded from matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    SumSymMatrix();
+
+    /** Copy Constructor */
+    SumSymMatrix(const SumSymMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const SumSymMatrix&);
+    //@}
+
+    /** std::vector storing the factors for each term. */
+    std::vector<Number> factors_;
+
+    /** std::vector storing the matrices for each term. */
+    std::vector<SmartPtr<const SymMatrix> > matrices_;
+
+    /** Copy of the owner_space as a SumSymMatrixSpace */
+    const SumSymMatrixSpace* owner_space_;
+  };
+
+  /** Class for matrix space for SumSymMatrix */
+  class SumSymMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the dimension of the matrix and the number
+     *  of terms in the sum. */
+    SumSymMatrixSpace(Index ndim, Index nterms)
+        :
+        SymMatrixSpace(ndim),
+        nterms_(nterms)
+    {}
+
+    /** Destructor */
+    ~SumSymMatrixSpace()
+    {}
+    //@}
+
+    /** @name Accessor functions */
+    //@{
+    /** Number of terms in the sum. */
+    Index NTerms() const
+    {
+      return nterms_;
+    }
+    //@}
+
+    /** Use this method to set the matrix spaces for the various terms.
+     *  You will not be able to create a matrix until all these spaces
+     *  are set. */
+    void SetTermSpace(Index term_idx, const SymMatrixSpace& space);
+
+    /** Get the matix space for a particular term */
+    SmartPtr<const SymMatrixSpace> GetTermSpace(Index term_idx) const;
+
+    /** Method for creating a new matrix of this specific type. */
+    SumSymMatrix* MakeNewSumSymMatrix() const;
+
+    /** Overloaded MakeNew method for the SymMatrixSpace base class.
+     */
+    virtual SymMatrix* MakeNewSymMatrix() const;
+
+  private:
+    Index nterms_;
+
+    std::vector< SmartPtr<const SymMatrixSpace> > term_spaces_;
+  };
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpSymLinearSolver.hpp b/thirdparty/linux/include/coin/IpSymLinearSolver.hpp
new file mode 100644
index 0000000..82e7dd4
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpSymLinearSolver.hpp
@@ -0,0 +1,130 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpSymLinearSolver.hpp 2322 2013-06-12 17:45:57Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPSYMLINEARSOLVER_HPP__
+#define __IPSYMLINEARSOLVER_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+#include "IpAlgStrategy.hpp"
+#include <vector>
+
+namespace Ipopt
+{
+
+  /** Enum to report outcome of a linear solve */
+  enum ESymSolverStatus {
+    /** Successful solve */
+    SYMSOLVER_SUCCESS,
+    /** Matrix seems to be singular; solve was aborted */
+    SYMSOLVER_SINGULAR,
+    /** The number of negative eigenvalues is not correct */
+    SYMSOLVER_WRONG_INERTIA,
+    /** Call the solver interface again after the matrix values have
+     *  been restored */
+    SYMSOLVER_CALL_AGAIN,
+    /** Unrecoverable error in linear solver occurred.  The
+     *  optimization will be aborted. */
+    SYMSOLVER_FATAL_ERROR
+  };
+
+  /** Base class for all derived symmetric linear
+   *  solvers.  In the full space version of Ipopt a large linear
+   *  system has to be solved for the augmented system.  This case is
+   *  meant to be the base class for all derived linear solvers for
+   *  symmetric matrices (of type SymMatrix).
+   *
+   *  A linear solver can be used repeatedly for matrices with
+   *  identical structure of nonzero elements.  The nonzero structure
+   *  of those matrices must not be changed between calls.
+   *
+   *  The called might ask the solver to only solve the linear system
+   *  if the system is nonsingular, and if the number of negative
+   *  eigenvalues matches a given number.
+   */
+  class SymLinearSolver: public AlgorithmStrategyObject
+  {
+  public:
+    /** @name Constructor/Destructor */
+    //@{
+    SymLinearSolver()
+    {}
+
+    virtual ~SymLinearSolver()
+    {}
+    //@}
+
+    /** overloaded from AlgorithmStrategyObject */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix) = 0;
+
+    /** @name Methods for requesting solution of the linear system. */
+    //@{
+    /** Solve operation for multiple right hand sides.  Solves the
+     *  linear system A * Sol = Rhs with multiple right hand sides.  If
+     *  necessary, A is factorized.  Correct solutions are only
+     *  guaranteed if the return values is SYMSOLVER_SUCCESS.  The
+     *  solver will return SYMSOLVER_SINGULAR if the linear system is
+     *  singular, and it will return SYMSOLVER_WRONG_INERTIA if
+     *  check_NegEVals is true and the number of negative eigenvalues
+     *  in the matrix does not match numberOfNegEVals.
+     *
+     *  check_NegEVals cannot be chosen true, if ProvidesInertia()
+     *  returns false.
+     */
+    virtual ESymSolverStatus MultiSolve(const SymMatrix &A,
+                                        std::vector<SmartPtr<const Vector> >& rhsV,
+                                        std::vector<SmartPtr<Vector> >& solV,
+                                        bool check_NegEVals,
+                                        Index numberOfNegEVals)=0;
+
+    /** Solve operation for a single right hand side. Solves the
+     *  linear system A * Sol = Rhs.  See MultiSolve for more
+     *  details. */
+    ESymSolverStatus Solve(const SymMatrix &A,
+                           const Vector& rhs, Vector& sol,
+                           bool check_NegEVals,
+                           Index numberOfNegEVals)
+    {
+      std::vector<SmartPtr<const Vector> > rhsV(1);
+      rhsV[0] = &rhs;
+      std::vector<SmartPtr<Vector> > solV(1);
+      solV[0] = &sol;
+      return MultiSolve(A, rhsV, solV, check_NegEVals,
+                        numberOfNegEVals);
+    }
+
+    /** Number of negative eigenvalues detected during last
+     *  factorization.  Returns the number of negative eigenvalues of
+     *  the most recent factorized matrix.  This must not be called if
+     *  the linear solver does not compute this quantities (see
+     *  ProvidesInertia).
+     */
+    virtual Index NumberOfNegEVals() const =0;
+    //@}
+
+    //* @name Options of Linear solver */
+    //@{
+    /** Request to increase quality of solution for next solve.
+     * Ask linear solver to increase quality of solution for the next
+     * solve (e.g. increase pivot tolerance).  Returns false, if this
+     * is not possible (e.g. maximal pivot tolerance already used.)
+     */
+    virtual bool IncreaseQuality() =0;
+
+    /** Query whether inertia is computed by linear solver.
+     * Returns true, if linear solver provides inertia.
+     */
+    virtual bool ProvidesInertia() const =0;
+    //@}
+  };
+
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpSymScaledMatrix.hpp b/thirdparty/linux/include/coin/IpSymScaledMatrix.hpp
new file mode 100644
index 0000000..d58742f
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpSymScaledMatrix.hpp
@@ -0,0 +1,230 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpSymScaledMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPSYMSCALEDMATRIX_HPP__
+#define __IPSYMSCALEDMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class SymScaledMatrixSpace;
+
+  /** Class for a Matrix in conjunction with its scaling factors for
+   *  row and column scaling. Operations on the matrix are performed using
+   *  the scaled matrix. You can pull out the pointer to the 
+   *  unscaled matrix for unscaled calculations.
+   */
+  class SymScaledMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the owner_space.
+     */
+    SymScaledMatrix(const SymScaledMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~SymScaledMatrix();
+    //@}
+
+    /** Set the unscaled matrix */
+    void SetUnscaledMatrix(const SmartPtr<const SymMatrix> unscaled_matrix);
+
+    /** Set the unscaled matrix in a non-const version */
+    void SetUnscaledMatrixNonConst(const SmartPtr<SymMatrix>& unscaled_matrix);
+
+    /** Return the unscaled matrix in const form */
+    SmartPtr<const SymMatrix> GetUnscaledMatrix() const;
+
+    /** Return the unscaled matrix in non-const form */
+    SmartPtr<SymMatrix> GetUnscaledMatrixNonConst();
+
+    /** return the vector for the row and column scaling */
+    SmartPtr<const Vector> RowColScaling() const;
+
+  protected:
+    /**@name Methods overloaded from Matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan).  It is assumed here that the scaling factors
+     *  are always valid numbers. */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    SymScaledMatrix();
+
+    /** Copy Constructor */
+    SymScaledMatrix(const SymScaledMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const SymScaledMatrix&);
+    //@}
+
+    /** const version of the unscaled matrix */
+    SmartPtr<const SymMatrix> matrix_;
+    /** non-const version of the unscaled matrix */
+    SmartPtr<SymMatrix> nonconst_matrix_;
+
+    /** Matrix space stored as a SymScaledMatrixSpace */
+    SmartPtr<const SymScaledMatrixSpace> owner_space_;
+  };
+
+  /** This is the matrix space for SymScaledMatrix.
+   */
+  class SymScaledMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of row and columns blocks, as
+     *  well as the totel number of rows and columns.
+     */
+    SymScaledMatrixSpace(const SmartPtr<const Vector>& row_col_scaling,
+                         bool row_col_scaling_reciprocal,
+                         const SmartPtr<const SymMatrixSpace>& unscaled_matrix_space)
+        :
+        SymMatrixSpace(unscaled_matrix_space->Dim()),
+        unscaled_matrix_space_(unscaled_matrix_space)
+    {
+      scaling_ = row_col_scaling->MakeNewCopy();
+      if (row_col_scaling_reciprocal) {
+        scaling_->ElementWiseReciprocal();
+      }
+    }
+
+    /** Destructor */
+    ~SymScaledMatrixSpace()
+    {}
+    //@}
+
+    /** Method for creating a new matrix of this specific type. */
+    SymScaledMatrix* MakeNewSymScaledMatrix(bool allocate_unscaled_matrix = false) const
+    {
+      SymScaledMatrix* ret = new SymScaledMatrix(this);
+      if (allocate_unscaled_matrix) {
+        SmartPtr<SymMatrix> unscaled_matrix = unscaled_matrix_space_->MakeNewSymMatrix();
+        ret->SetUnscaledMatrixNonConst(unscaled_matrix);
+      }
+      return ret;
+    }
+
+    /** Overloaded method from SymMatrixSpace */
+    virtual SymMatrix* MakeNewSymMatrix() const
+    {
+      return MakeNewSymScaledMatrix();
+    }
+    /** Overloaded MakeNew method for the MatrixSpace base class.
+     */
+    virtual Matrix* MakeNew() const
+    {
+      return MakeNewSymScaledMatrix();
+    }
+
+    /** return the vector for the row and column scaling */
+    SmartPtr<const Vector> RowColScaling() const
+    {
+      return ConstPtr(scaling_);
+    }
+
+    /** return the matrix space for the unscaled matrix */
+    SmartPtr<const SymMatrixSpace> UnscaledMatrixSpace() const
+    {
+      return unscaled_matrix_space_;
+    }
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default constructor */
+    SymScaledMatrixSpace();
+
+    /** Copy Constructor */
+    SymScaledMatrixSpace(const SymScaledMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    SymScaledMatrixSpace& operator=(const SymScaledMatrixSpace&);
+    //@}
+
+    /** Row scaling vector */
+    SmartPtr<Vector> scaling_;
+    /** unscaled matrix space */
+    SmartPtr<const SymMatrixSpace> unscaled_matrix_space_;
+  };
+
+  inline
+  void SymScaledMatrix::SetUnscaledMatrix(const SmartPtr<const SymMatrix> unscaled_matrix)
+  {
+    matrix_ = unscaled_matrix;
+    nonconst_matrix_ = NULL;
+    ObjectChanged();
+  }
+
+  inline
+  void SymScaledMatrix::SetUnscaledMatrixNonConst(const SmartPtr<SymMatrix>& unscaled_matrix)
+  {
+    nonconst_matrix_ = unscaled_matrix;
+    matrix_ = GetRawPtr(unscaled_matrix);
+    ObjectChanged();
+  }
+
+  inline
+  SmartPtr<const SymMatrix> SymScaledMatrix::GetUnscaledMatrix() const
+  {
+    return matrix_;
+  }
+
+  inline
+  SmartPtr<SymMatrix> SymScaledMatrix::GetUnscaledMatrixNonConst()
+  {
+    DBG_ASSERT(IsValid(nonconst_matrix_));
+    ObjectChanged();
+    return nonconst_matrix_;
+  }
+
+  inline SmartPtr<const Vector> SymScaledMatrix::RowColScaling() const
+  {
+    return ConstPtr(owner_space_->RowColScaling());
+  }
+
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpSymTMatrix.hpp b/thirdparty/linux/include/coin/IpSymTMatrix.hpp
new file mode 100644
index 0000000..ead2d85
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpSymTMatrix.hpp
@@ -0,0 +1,253 @@
+// Copyright (C) 2004, 2006 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpSymTMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPSYMTMATRIX_HPP__
+#define __IPSYMTMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /* forward declarations */
+  class SymTMatrixSpace;
+
+  /** Class for symmetric matrices stored in triplet format.  In the
+   *  triplet format, the nonzeros elements of a symmetric matrix is
+   *  stored in three arrays, Irn, Jcn, and Values, all of length
+   *  Nonzeros.  The first two arrays indicate the location of a
+   *  non-zero element (as the row and column indices), and the last
+   *  array stores the value at that location.  Off-diagonal elements
+   *  need to be stored only once since the matrix is symmetric.  For
+   *  example, the element \f$a_{1,2}=a_{2,1}\f$ would be stored only
+   *  once, either with Irn[i]=1 and Jcn[i]=2, or with Irn[i]=2 and
+   *  Jcn[i]=1.  Both representations are identical.  If nonzero
+   *  elements (or their symmetric counter part) are listed more than
+   *  once, their values are added.
+   *
+   *  The structure of the nonzeros (i.e. the arrays Irn and Jcn)
+   *  cannot be changed after the matrix can been initialized.  Only
+   *  the values of the nonzero elements can be modified.
+   *
+   *  Note that the first row and column of a matrix has index 1, not
+   *  0.
+   *
+   */
+  class SymTMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the corresponding matrix space.
+     */
+    SymTMatrix(const SymTMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~SymTMatrix();
+    //@}
+
+    /**@name Changing the Values.*/
+    //@{
+    /** Set values of nonzero elements.  The values of the nonzero
+     *  elements is copied from the incoming Number array.  Important:
+     *  It is assume that the order of the values in Values
+     *  corresponds to the one of Irn and Jcn given to the matrix
+     *  space. */
+    void SetValues(const Number* Values);
+    //@}
+
+    /** @name Accessor Methods */
+    //@{
+    /** Number of nonzero entries */
+    Index Nonzeros() const;
+
+    /** Obtain pointer to the internal Index array irn_ without the
+     *  intention to change the matrix data (USE WITH CARE!).  This
+     *  does not produce a copy, and lifetime is not guaranteed!
+     */
+    const Index* Irows() const;
+
+    /** Obtain pointer to the internal Index array jcn_ without the
+     *  intention to change the matrix data (USE WITH CARE!).  This
+     *  does not produce a copy, and lifetime is not guaranteed!
+     */
+    const Index* Jcols() const;
+
+    /** Obtain pointer to the internal Number array values_ with the
+     *  intention to change the matrix data (USE WITH CARE!).  This
+     *  does not produce a copy, and lifetime is not guaranteed!
+     */
+    Number* Values();
+    /** Obtain pointer to the internal Number array values_ without the
+     *  intention to change the matrix data (USE WITH CARE!).  This
+     *  does not produce a copy, and lifetime is not guaranteed!
+     */
+    const Number* Values() const;
+    //@}
+
+    /**@name Methods for providing copy of the matrix data */
+    //@{
+    /** Copy the nonzero structure into provided space */
+    void FillStruct(ipfint* Irn, ipfint* Jcn) const;
+
+    /** Copy the value data into provided space */
+    void FillValues(Number* Values) const;
+    //@}
+
+  protected:
+    /**@name Methods overloaded from matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x, Number beta,
+                                Vector& y) const;
+
+    /** Method for determining if all stored numbers are valid (i.e.,
+     *  no Inf or Nan). */
+    virtual bool HasValidNumbersImpl() const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const;
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    SymTMatrix();
+
+    /** Copy Constructor */
+    SymTMatrix(const SymTMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const SymTMatrix&);
+    //@}
+
+    /** Copy of the owner_space ptr as a SymTMatrixSpace insteaqd
+     *  of a MatrixSpace
+     */
+    const SymTMatrixSpace* owner_space_;
+
+    /** Values of nonzeros */
+    Number* values_;
+
+    /** Flag for Initialization */
+    bool initialized_;
+
+  };
+
+  /** This is the matrix space for a SymTMatrix with fixed sparsity
+   *  structure.  The sparsity structure is stored here in the matrix
+   *  space.
+   */
+  class SymTMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of rows and columns (both as
+     *  dim), as well as the number of nonzeros and the position of
+     *  the nonzero elements.  Note that the counting of the nonzeros
+     *  starts a 1, i.e., iRows[i]==1 and jCols[i]==1 refers to the
+     *  first element in the first row.  This is in accordance with
+     *  the HSL data structure.  Off-diagonal elements are stored only
+     *  once.
+     */
+    SymTMatrixSpace(Index dim, Index nonZeros, const Index* iRows,
+                    const Index* jCols);
+
+    /** Destructor */
+    ~SymTMatrixSpace();
+    //@}
+
+    /** Overloaded MakeNew method for the sYMMatrixSpace base class.
+     */
+    virtual SymMatrix* MakeNewSymMatrix() const
+    {
+      return MakeNewSymTMatrix();
+    }
+
+    /** Method for creating a new matrix of this specific type. */
+    SymTMatrix* MakeNewSymTMatrix() const
+    {
+      return new SymTMatrix(this);
+    }
+
+    /**@name Methods describing Matrix structure */
+    //@{
+    /** Number of non-zeros in the sparse matrix */
+    Index Nonzeros() const
+    {
+      return nonZeros_;
+    }
+
+    /** Row index of each non-zero element */
+    const Index* Irows() const
+    {
+      return iRows_;
+    }
+
+    /** Column index of each non-zero element */
+    const Index* Jcols() const
+    {
+      return jCols_;
+    }
+    //@}
+
+  private:
+    /**@name Methods called by SymTMatrix for memory management */
+    //@{
+    /** Allocate internal storage for the SymTMatrix values */
+    Number* AllocateInternalStorage() const;
+
+    /** Deallocate internal storage for the SymTMatrix values */
+    void FreeInternalStorage(Number* values) const;
+    //@}
+
+    const Index nonZeros_;
+    Index* iRows_;
+    Index* jCols_;
+
+    friend class SymTMatrix;
+  };
+
+  /* Inline Methods */
+  inline
+  Index SymTMatrix::Nonzeros() const
+  {
+    return owner_space_->Nonzeros();
+  }
+
+  inline
+  const Index* SymTMatrix::Irows() const
+  {
+    return owner_space_->Irows();
+  }
+
+  inline
+  const Index* SymTMatrix::Jcols() const
+  {
+    return owner_space_->Jcols();
+  }
+
+
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpTaggedObject.hpp b/thirdparty/linux/include/coin/IpTaggedObject.hpp
index e81b065..7262c43 100644
--- a/thirdparty/linux/include/coin/IpTaggedObject.hpp
+++ b/thirdparty/linux/include/coin/IpTaggedObject.hpp
@@ -2,7 +2,7 @@
 // All Rights Reserved.
 // This code is published under the Eclipse Public License.
 //
-// $Id: IpTaggedObject.hpp 2491 2014-05-31 11:17:49Z stefan $
+// $Id: IpTaggedObject.hpp 2613 2015-11-04 14:42:02Z stefan $
 //
 // Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
@@ -17,12 +17,13 @@
 
 /* keyword to declare a thread-local variable according to http://en.wikipedia.org/wiki/Thread-local_storage
  * GCC < 4.5 on MacOS X does not support TLS
+ * With Intel compiler on MacOS X, problems with TLS were reported.
  */
 #ifndef IPOPT_THREAD_LOCAL
 
 #if defined(_MSC_VER)
 #define IPOPT_THREAD_LOCAL __declspec(thread)
-#elif defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 405)
+#elif defined(__APPLE__) && ((defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 405)) || defined(__INTEL_COMPILER))
 #define IPOPT_THREAD_LOCAL
 #else
 #define IPOPT_THREAD_LOCAL __thread
diff --git a/thirdparty/linux/include/coin/IpTripletHelper.hpp b/thirdparty/linux/include/coin/IpTripletHelper.hpp
new file mode 100644
index 0000000..35424c0
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpTripletHelper.hpp
@@ -0,0 +1,135 @@
+// Copyright (C) 2004, 2009 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpTripletHelper.hpp 2380 2013-09-06 22:57:49Z ghackebeil $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPTRIPLETHELPER_HPP__
+#define __IPTRIPLETHELPER_HPP__
+
+#include "IpTypes.hpp"
+#include "IpException.hpp"
+
+namespace Ipopt
+{
+
+  DECLARE_STD_EXCEPTION(UNKNOWN_MATRIX_TYPE);
+  DECLARE_STD_EXCEPTION(UNKNOWN_VECTOR_TYPE);
+
+  /** forward declarations */
+  class Matrix;
+  class GenTMatrix;
+  class SymTMatrix;
+  class DiagMatrix;
+  class IdentityMatrix;
+  class ExpansionMatrix;
+  class ScaledMatrix;
+  class SymScaledMatrix;
+  class SumMatrix;
+  class SumSymMatrix;
+  class ZeroMatrix;
+  class ZeroSymMatrix;
+  class CompoundMatrix;
+  class CompoundSymMatrix;
+  class TransposeMatrix;
+  class ExpandedMultiVectorMatrix;
+  class Vector;
+
+  class TripletHelper
+  {
+  public:
+    /**@name A set of recursive routines that help with the Triplet format. */
+    //@{
+    /** find the total number of triplet entries of a Matrix */
+    static Index GetNumberEntries(const Matrix& matrix);
+
+    /** fill the irows, jcols structure for the triplet format from the matrix */
+    static void FillRowCol(Index n_entries, const Matrix& matrix, Index* iRow, Index* jCol, Index row_offset=0, Index col_offset=0);
+
+    /** fill the values for the triplet format from the matrix */
+    static void FillValues(Index n_entries, const Matrix& matrix, Number* values);
+
+    /** fill the values from the vector into a dense double* structure */
+    static void FillValuesFromVector(Index dim, const Vector& vector, Number* values);
+
+    /** put the values from the double* back into the vector */
+    static void PutValuesInVector(Index dim, const double* values, Vector& vector);
+    //@}
+
+  private:
+    /** find the total number of triplet entries for the SumMatrix */
+    static Index GetNumberEntries_(const SumMatrix& matrix);
+
+    /** find the total number of triplet entries for the SumSymMatrix */
+    static Index GetNumberEntries_(const SumSymMatrix& matrix);
+
+    /** find the total number of triplet entries for the CompoundMatrix */
+    static Index GetNumberEntries_(const CompoundMatrix& matrix);
+
+    /** find the total number of triplet entries for the CompoundSymMatrix */
+    static Index GetNumberEntries_(const CompoundSymMatrix& matrix);
+
+    /** find the total number of triplet entries for the TransposeMatrix */
+    static Index GetNumberEntries_(const TransposeMatrix& matrix);
+
+    /** find the total number of triplet entries for the TransposeMatrix */
+    static Index GetNumberEntries_(const ExpandedMultiVectorMatrix& matrix);
+
+    static void FillRowCol_(Index n_entries, const GenTMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const GenTMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const SymTMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const SymTMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const DiagMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const DiagMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const IdentityMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const IdentityMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const ExpansionMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const ExpansionMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const SumMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const SumMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const SumSymMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const SumSymMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const CompoundMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const CompoundMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const CompoundSymMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const CompoundSymMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const ScaledMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const ScaledMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const SymScaledMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const SymScaledMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const TransposeMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const TransposeMatrix& matrix, Number* values);
+
+    static void FillRowCol_(Index n_entries, const ExpandedMultiVectorMatrix& matrix, Index row_offset, Index col_offset, Index* iRow, Index* jCol);
+
+    static void FillValues_(Index n_entries, const ExpandedMultiVectorMatrix& matrix, Number* values);
+
+  };
+} // namespace Ipopt
+
+#endif
diff --git a/thirdparty/linux/include/coin/IpZeroSymMatrix.hpp b/thirdparty/linux/include/coin/IpZeroSymMatrix.hpp
new file mode 100644
index 0000000..35ad95e
--- /dev/null
+++ b/thirdparty/linux/include/coin/IpZeroSymMatrix.hpp
@@ -0,0 +1,135 @@
+// Copyright (C) 2004, 2008 International Business Machines and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+//
+// $Id: IpZeroSymMatrix.hpp 2269 2013-05-05 11:32:40Z stefan $
+//
+// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
+
+#ifndef __IPZEROSYMMATRIX_HPP__
+#define __IPZEROSYMMATRIX_HPP__
+
+#include "IpUtils.hpp"
+#include "IpSymMatrix.hpp"
+
+namespace Ipopt
+{
+
+  /** Class for Symmetric Matrices with only zero entries.
+   */
+  class ZeroSymMatrix : public SymMatrix
+  {
+  public:
+
+    /**@name Constructors / Destructors */
+    //@{
+
+    /** Constructor, taking the corresponding matrix space.
+     */
+    ZeroSymMatrix(const SymMatrixSpace* owner_space);
+
+    /** Destructor */
+    ~ZeroSymMatrix();
+    //@}
+
+  protected:
+    /**@name Methods overloaded from matrix */
+    //@{
+    virtual void MultVectorImpl(Number alpha, const Vector& x,
+                                Number beta, Vector& y) const;
+
+    virtual void TransMultVectorImpl(Number alpha, const Vector& x,
+                                     Number beta, Vector& y) const;
+
+    virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const
+      {}
+
+    virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const
+      {}
+
+    virtual void PrintImpl(const Journalist& jnlst,
+                           EJournalLevel level,
+                           EJournalCategory category,
+                           const std::string& name,
+                           Index indent,
+                           const std::string& prefix) const;
+    //@}
+
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    ZeroSymMatrix();
+
+    /** Copy Constructor */
+    ZeroSymMatrix(const ZeroSymMatrix&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const ZeroSymMatrix&);
+    //@}
+  };
+
+  /** Class for matrix space for ZeroSymMatrix. */
+  class ZeroSymMatrixSpace : public SymMatrixSpace
+  {
+  public:
+    /** @name Constructors / Destructors */
+    //@{
+    /** Constructor, given the number of row and columns.
+     */
+    ZeroSymMatrixSpace(Index dim)
+        :
+        SymMatrixSpace(dim)
+    {}
+
+    /** Destructor */
+    virtual ~ZeroSymMatrixSpace()
+    {}
+    //@}
+
+    /** Overloaded MakeNew method for the MatrixSpace base class.
+     */
+    virtual Matrix* MakeNew() const
+    {
+      return MakeNewZeroSymMatrix();
+    }
+
+    /** Overloaded method from SymMatrixSpace base class
+     */
+    virtual SymMatrix* MakeNewSymMatrix() const
+    {
+      return MakeNewZeroSymMatrix();
+    }
+
+    /** Method for creating a new matrix of this specific type. */
+    ZeroSymMatrix* MakeNewZeroSymMatrix() const
+    {
+      return new ZeroSymMatrix(this);
+    }
+  private:
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+    /** Default Constructor */
+    ZeroSymMatrixSpace();
+
+    /** Copy Constructor */
+    ZeroSymMatrixSpace(const ZeroSymMatrixSpace&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const ZeroSymMatrixSpace&);
+    //@}
+  };
+} // namespace Ipopt
+#endif
diff --git a/thirdparty/linux/include/coin/IpoptConfig.h b/thirdparty/linux/include/coin/IpoptConfig.h
index e7de361..78dadd3 100644
--- a/thirdparty/linux/include/coin/IpoptConfig.h
+++ b/thirdparty/linux/include/coin/IpoptConfig.h
@@ -5,7 +5,7 @@
 #define __CONFIG_IPOPT_H__
 
 /* Version number of project */
-#define IPOPT_VERSION "3.12.4"
+#define IPOPT_VERSION "3.12.7"
 
 /* Major Version number of project */
 #define IPOPT_VERSION_MAJOR 3
@@ -14,7 +14,7 @@
 #define IPOPT_VERSION_MINOR 12
 
 /* Release Version number of project */
-#define IPOPT_VERSION_RELEASE 4
+#define IPOPT_VERSION_RELEASE 7
 
 /* Define to the C type corresponding to Fortran INTEGER */
 #define FORTRAN_INTEGER_TYPE int
diff --git a/thirdparty/linux/lib/x64/libcoinmumps.so b/thirdparty/linux/lib/x64/libcoinmumps.so
index 03e6e54..c2d14a9 100755..120000
--- a/thirdparty/linux/lib/x64/libcoinmumps.so
+++ b/thirdparty/linux/lib/x64/libcoinmumps.so
diff --git a/thirdparty/linux/lib/x64/libcoinmumps.so.1 b/thirdparty/linux/lib/x64/libcoinmumps.so.1
index 03e6e54..c2d14a9 100755..120000
--- a/thirdparty/linux/lib/x64/libcoinmumps.so.1
+++ b/thirdparty/linux/lib/x64/libcoinmumps.so.1
diff --git a/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 b/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
index 2cb7e1c..03e6e54 100755
--- a/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
+++ b/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
diff --git a/thirdparty/linux/lib/x64/libipopt.so.1.10.4 b/thirdparty/linux/lib/x64/libipopt.so.1.10.4
deleted file mode 100755
index 7808b17..0000000
--- a/thirdparty/linux/lib/x64/libipopt.so.1.10.4
+++ /dev/null