From 9fd2976931c088dc523974afb901e96bad20f73c Mon Sep 17 00:00:00 2001
From: Harpreet
Date: Thu, 4 Aug 2016 15:25:44 +0530
Subject: initial add

---
 build/cpp/sci_minconTMINLP.cpp~ | 267 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 267 insertions(+)
 create mode 100644 build/cpp/sci_minconTMINLP.cpp~

(limited to 'build/cpp/sci_minconTMINLP.cpp~')

diff --git a/build/cpp/sci_minconTMINLP.cpp~ b/build/cpp/sci_minconTMINLP.cpp~
new file mode 100644
index 0000000..2b9cbc3
--- /dev/null
+++ b/build/cpp/sci_minconTMINLP.cpp~
@@ -0,0 +1,267 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// Author: Harpreet Singh, Pranav Deshpande and Akshay Miterani
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+#include "minconTMINLP.hpp"
+#include "sci_iofunc.hpp"
+
+extern "C"
+{
+#include "call_scilab.h"
+#include <api_scilab.h>
+#include <Scierror.h>
+#include <BOOL.h>
+#include <localization.h>
+#include <sciprint.h>
+#include <string.h>
+#include <assert.h>
+}
+
+using namespace Ipopt;
+using namespace Bonmin;
+
+minconTMINLP::~minconTMINLP()
+{
+	free(finalX_);
+}
+
+// Set the type of every variable - CONTINUOUS or INTEGER
+bool minconTMINLP::get_variables_types(Index n, VariableType* var_types)
+{
+  n = numVars_;
+  for(int i=0; i < n; i++)
+    var_types[i] = CONTINUOUS;
+  for(int i=0 ; i < intconSize_ ; ++i)
+  	var_types[(int)(intcon_[i]-1)] = INTEGER;
+  return true;
+}
+
+// The linearity of the variables - LINEAR or NON_LINEAR
+bool minconTMINLP::get_variables_linearity(Index n, Ipopt::TNLP::LinearityType* var_types)
+{  return true; }
+
+// The linearity of the constraints - LINEAR or NON_LINEAR
+bool minconTMINLP::get_constraints_linearity(Index m, Ipopt::TNLP::LinearityType* const_types)
+{  return true;}
+
+//get NLP info such as number of variables,constraints,no.of elements in jacobian and hessian to allocate memory
+bool minconTMINLP::get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, Index& nnz_h_lag, TNLP::IndexStyleEnum& index_style)
+{
+	n=numVars_; // Number of variables
+	m=numCons_; // Number of constraints
+	nnz_jac_g = 0; // No. of elements in Jacobian of constraints 
+	nnz_h_lag = n*(n+1)/2; // No. of elements in lower traingle of Hessian of the Lagrangian.
+	index_style=TNLP::C_STYLE; // Index style of matrices
+	return true;
+}
+
+//get variable and constraint bound info
+bool minconTMINLP::get_bounds_info(Index n, Number* x_l, Number* x_u, Index m, Number* g_l, Number* g_u)
+{
+	unsigned int i;
+	for(i=0;i<n;i++)
+	{
+		x_l[i]=lb_[i];
+		x_u[i]=ub_[i];
+	}
+
+	for(i=0;i<m;i++)
+        g_l=conLb_[i];
+        g_u=conUb_[i];
+	return true;
+}
+
+// return the value of the constraints: g(x)
+bool minconTMINLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)
+{
+  	// return the value of the constraints: g(x)
+  	if(m==0)
+  	{
+  		g=NULL;
+  	}  		
+	else
+	{
+	  	char name[20]="_addnlc";
+	  	Number *con;
+		if (getFunctionFromScilab(n,name,x, 7, 1,2,&con))
+		{
+			return false;
+		}
+		
+		Index i;
+		for(i=0;i<m;i++)
+		{
+			g[i]=con[i];
+		}
+	}
+  	return true;
+}
+
+// return the structure or values of the jacobian
+bool minconTMINLP::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(m==0)// return the structure of the jacobian of the constraints
+    	{
+			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
+		{
+			double* resj;
+			if (getFunctionFromScilab(n,name,x, 7, 1,2,&resj))
+			{
+				return false;
+			}
+			for(j=0;j<n;j++)
+			{
+				values[c] = resj[j*(int)nonlinCon_+i];
+				c++;
+			}
+		}	
+	}	
+
+
+  	return true;
+}
+
+//get value of objective function at vector x
+bool minconTMINLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value)
+{	
+  	char name[20]="_f";
+	Number *obj;
+	if (getFunctionFromScilab(n,name,x, 7, 1,2,&obj))
+	{
+		return false;
+	}
+	obj_value = *obj;
+  	return true;
+}
+
+//get value of gradient of objective function at vector x.
+bool minconTMINLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f)
+{
+	char name[20]="_gradf";
+  	Number *resg;
+	if (getFunctionFromScilab(n,name,x, 7, 1,2,&resg))
+	{
+		return false;
+	}
+	
+	Index i;
+	for(i=0;i<numVars_;i++)
+	{
+		grad_f[i]=resg[i];
+	}
+  	return true;
+}
+
+// This method sets initial values for required vectors . For now we are assuming 0 to all values. 
+bool minconTMINLP::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);
+	if (init_x == true)
+	{ //we need to set initial values for vector x
+		for (Index var=0;var<n;var++)
+			{x[var]=x0_[i];}//initialize with 0.
+	}
+	return true;
+}
+
+/*
+ * Return either the sparsity structure of the Hessian of the Lagrangian, 
+ * or the values of the Hessian of the Lagrangian  for the given values for
+ * x,lambda,obj_factor.
+*/
+
+bool minconTMINLP::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)
+{
+	double check;
+	if (values==NULL)
+	{
+		Index idx=0;
+		for (Index row = 0; row < numVars_; row++) 
+		{
+			for (Index col = 0; col <= row; col++)
+			{	iRow[idx] = row;
+				jCol[idx] = col;
+				idx++;
+		  	}
+		}
+	}
+
+	else 
+	{	char name[20]="_gradhess";
+	  	Number *resh;
+		if (getFunctionFromScilab(n,name,x, 7, 1,2,&resh))
+		{
+			return false;
+		}
+		Index index=0;
+		for (Index row=0;row < numVars_ ;++row)
+		{
+			for (Index col=0; col <= row; ++col)
+			{
+				values[index++]=obj_factor*(resh[numVars_*row+col]);
+			}
+		}
+	}
+       	return true;
+}
+
+void minconTMINLP::finalize_solution(SolverReturn status,Index n, const Number* x, Number obj_value)
+{
+	finalObjVal_ = obj_value;
+	status_ = status;
+	if(status==0 ||status== 3)
+	{
+		finalX_ = (double*)malloc(sizeof(double) * numVars_ * 1);
+		for (Index i=0; i<numVars_; i++) 
+		{
+	    		 finalX_[i] = x[i];
+		}
+	}
+
+}
+
+const double * minconTMINLP::getX()
+{	
+	return finalX_;
+}
+
+double minconTMINLP::getObjVal()
+{	
+	return finalObjVal_;
+}
+
+int minconTMINLP::returnStatus()
+{	
+	return status_;
+}
-- 
cgit