initial add

5 files changed, 1337 insertions, 0 deletions

diff --git a/build/Scilab/Checktype.sci b/build/Scilab/Checktype.sci
new file mode 100644
index 0000000..0465d7f
--- /dev/null
+++ b/build/Scilab/Checktype.sci
@@ -0,0 +1,62 @@
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+// This file must be used under the terms of the GNU LGPL license.
+
+function errmsg = Checktype ( funname , var , varname , ivar , expectedtype )
+  // Generates an error if the given variable is not of expected type.
+  //
+  // Calling Sequence
+  //   errmsg = Checktype ( funname , var , varname , ivar , expectedtype )
+  //
+  // Parameters
+  //   funname : a 1 x 1 matrix of strings, the name of the calling function.
+  //   var : a 1 x 1 matrix of valid Scilab data type, the variable
+  //   varname : a 1 x 1 matrix of string, the name of the variable
+  //   ivar : a 1 x 1 matrix of floating point integers, the index of the input argument in the calling sequence
+  //   expectedtype : a n x 1 or 1 x n matrix of strings, the available types for the variable #ivar
+  //   errmsg : a 1 x 1 matrix of strings, the error message. If there was no error, the error message is the empty matrix.
+  //
+  // Description
+  // This function is designed to be used to design functions with 
+  // input arguments with variable type.
+  // We use the typeof function to compute the type of the variable:
+  // see help typeof to get the list of all available values for expectedtype.
+  //   Last update : 29/07/2010.
+  //
+  // Examples
+  // // The function takes a string argument.
+  // function myfunction ( x )
+  //   Checktype ( "myfunction" , x , "x" , 1 , "string" )
+  //   disp("This is a string")
+  // endfunction
+  // // Calling sequences which work
+  // myfunction ( "Scilab" )
+  // // Calling sequences which generate an error
+  // myfunction ( 123456 )
+  //
+  // // The function takes a string or a matrix of doubles argument.
+  // function myfunction ( x )
+  //   Checktype ( "myfunction" , x , "x" , 1 , [ "string" "constant" ] )
+  //   if ( typeof(x) == "string" ) then
+  //     disp("This is a matrix of strings")
+  //   else
+  //     disp("This is a matrix of doubles")
+  //   end
+  // endfunction
+  // // Calling sequences which work
+  // myfunction ( "Scilab" )
+  // myfunction ( 123456 )
+  // // Calling sequences which generate an error
+  // myfunction ( uint8(2) )
+  //
+  // Authors
+  //   Michael Baudin - 2010 - DIGITEO
+  //
+
+  errmsg = []
+  if ( and ( typeof ( var ) <> expectedtype ) ) then
+    strexp = """" + strcat(expectedtype,""" or """) + """"
+    errmsg = msprintf(gettext("%s: Expected type [%s] for input argument %s at input #%d, but got ""%s"" instead."),funname, strexp, varname , ivar , typeof(var) );
+    error(errmsg);
+  end
+endfunction
diff --git a/build/Scilab/Checkvector.sci b/build/Scilab/Checkvector.sci
new file mode 100644
index 0000000..f24a92d
--- /dev/null
+++ b/build/Scilab/Checkvector.sci
@@ -0,0 +1,63 @@
+// Copyright (C) 2010 - DIGITEO - Michael Baudin
+//
+// This file must be used under the terms of the GNU LGPL license.
+
+function errmsg = Checkvector ( funname , var , varname , ivar , nbval )
+  // Generates an error if the variable is not a vector.
+  //
+  // Calling Sequence
+  //   errmsg = Checkvector ( funname , var , varname , ivar )
+  //
+  // Parameters
+  //   funname : a 1 x 1 matrix of strings, the name of the calling function.
+  //   var : a 1 x 1 matrix of valid Scilab data type, the variable
+  //   varname : a 1 x 1 matrix of string, the name of the variable
+  //   ivar : a 1 x 1 matrix of floating point integers, the index of the input argument in the calling sequence
+  //   nbval : a 1 x 1 matrix of floating point integers, the number of entries in the vector.
+  //   errmsg : a 1 x 1 matrix of strings, the error message. If there was no error, the error message is the empty matrix.
+  //
+  // Description
+  // This function is designed to be used to design functions where 
+  // the input argument is a vector, that is, a matrix for which 
+  // nrows == 1 or ncols == 1.
+  // This function cannot be use when var is a function, or more
+  // generally, for any input argument for which the size function
+  // does not work.
+  //
+  // Examples
+  // // The function takes a vector of 3 doubles.
+  // function y = myfunction ( x )
+  //   Checkvector ( "myfunction" , x , "x" , 1 , 3 )
+  //   y = x
+  // endfunction
+  // // Calling sequences which work
+  // y = myfunction ( ones(1,3) )
+  // y = myfunction ( zeros(3,1) )
+  // // Calling sequences which generate an error
+  // // The following are not vectors
+  // y = myfunction ( ones(2,3) )
+  // y = myfunction ( zeros(3,2) )
+  // // The following have the wrong number of entries
+  // y = myfunction ( ones(1,3) )
+  //
+  // Authors
+  //   Michael Baudin - 2010 - DIGITEO
+  //
+
+  errmsg = []
+  nrows = size(var,"r")
+  ncols = size(var,"c")
+  if ( nrows <> 1 & ncols <> 1 ) then
+    strcomp = strcat(string(size(var))," ")
+    errmsg = msprintf(gettext("%s: Expected a vector matrix for input argument %s at input #%d, but current dimensions are [%s] instead."), funname, varname , ivar , strcomp );
+    error(errmsg)
+  end
+  if ( ( nrows == 1 & ncols <> nbval ) | ( ncols == 1 & nrows <> nbval ) ) then
+    strcomp = strcat(string(size(var))," ")
+    errmsg = msprintf(gettext("%s: Expected %d entries for input argument %s at input #%d, but current dimensions are [%s] instead."), funname, nbval , varname , ivar , strcomp );
+    error(errmsg)
+  end
+endfunction
+
+
+
diff --git a/build/Scilab/intfminbnd.sci b/build/Scilab/intfminbnd.sci
new file mode 100644
index 0000000..2304bbf
--- /dev/null
+++ b/build/Scilab/intfminbnd.sci
@@ -0,0 +1,360 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// 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
+// Author: Harpreet Singh, Pranav Deshpande and Akshay Miterani
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+function [xopt,fopt,exitflag,gradient,hessian] = intfminbnd (varargin)
+	// Solves a multi-variable mixed integer non linear programming optimization problem on a bounded interval
+	//
+	//   Calling Sequence
+	//   xopt = intfminbnd(f,intcon,x1,x2)
+	//   xopt = intfminbnd(f,intcon,x1,x2,options)
+	//   [xopt,fopt] = intfminbnd(.....)
+	//   [xopt,fopt,exitflag]= intfminbnd(.....)
+	//   [xopt,fopt,exitflag,output]=intfminbnd(.....)
+	//   [xopt,fopt,exitflag,gradient,hessian]=intfminbnd(.....)
+	//
+	//   Parameters
+	//   f : a function, representing the objective function of the problem 
+	//   x1 : a vector, containing the lower bound of the variables.
+	//   x2 : a vector, containing the upper bound of the variables.
+  //   intcon : a vector of integers, represents which variables are constrained to be integers
+	//   options : a list, containing the option for user to specify. See below for details.
+	//   xopt : a vector of doubles, containing the the computed solution of the optimization problem.
+	//   fopt : a scalar of double, containing the the function value at x.
+	//   exitflag : a scalar of integer, containing the flag which denotes the reason for termination of algorithm. See below for details.
+  //   gradient : a vector of doubles, containing the Objective's gradient of the solution.
+  //   hessian  : a matrix of doubles, containing the Objective's hessian of the solution.
+	//
+	//   Description
+	//   Search the minimum of a multi-variable mixed integer non linear programming optimization on bounded interval specified by :
+	//   Find the minimum of f(x) such that 
+	//
+	//   <latex>
+	//    \begin{eqnarray}
+	//    &\mbox{min}_{x}
+	//    & f(x)\\
+	//    & \text{subject to} & x1 \ < x \ < x2 \\
+  //    & x_i \in \!\, \mathbb{Z}, i \in \!\, I
+	//    \end{eqnarray}
+	//   </latex>
+	//
+	//   The routine calls Bonmin for solving the Bounded Optimization problem, Bonmin is a library written in C++.
+	//
+	// The options allows the user to set various parameters of the Optimization problem. 
+	// It should be defined as type "list" and contains the following fields.
+	// <itemizedlist>
+	//   <listitem>Syntax : options= list("IntegerTolerance", [---], "MaxNodes",[---], "MaxIter", [---], "AllowableGap",[---] "CpuTime", [---],"gradobj", "off", "hessian", "off" );</listitem>
+  //   <listitem>IntegerTolerance : a Scalar, a number with that value of an integer is considered integer..</listitem>
+  //   <listitem>MaxNodes : a Scalar, containing the Maximum Number of Nodes that the solver should search.</listitem>
+	//   <listitem>CpuTime : a Scalar, containing the Maximum amount of CPU Time that the solver should take.</listitem>
+	//   <listitem>AllowableGap : a Scalar, to stop the tree search when the gap between the objective value of the best known solution is reached.</listitem>
+  //   <listitem>MaxIter : a Scalar, containing the Maximum Number of Iteration that the solver should take.</listitem>
+  //   <listitem>gradobj : a string, to turn on or off the user supplied objective gradient.</listitem>
+  //   <listitem>hessian : a Scalar, to turn on or off the user supplied objective hessian.</listitem>
+	//   <listitem>Default Values : options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian',"off")</listitem>
+	// </itemizedlist>
+	//
+	// The exitflag allows to know the status of the optimization which is given back by Ipopt.
+	// <itemizedlist>
+	//   <listitem>exitflag=0 : Optimal Solution Found </listitem>
+	//   <listitem>exitflag=1 : Maximum Number of Iterations Exceeded. Output may not be optimal.</listitem>
+	//   <listitem>exitflag=2 : Maximum CPU Time exceeded. Output may not be optimal.</listitem>
+	//   <listitem>exitflag=3 : Stop at Tiny Step.</listitem>
+	//   <listitem>exitflag=4 : Solved To Acceptable Level.</listitem>
+	//   <listitem>exitflag=5 : Converged to a point of local infeasibility.</listitem>
+	// </itemizedlist>
+	//
+	// For more details on exitflag see the Bonmin documentation, go to http://www.coin-or.org/Bonmin
+  //
+	// Examples
+	//	//Find x in R^6 such that it minimizes:
+	//    //f(x)= sin(x1) + sin(x2) + sin(x3) + sin(x4) + sin(x5) + sin(x6)
+	//	//-2 <= x1,x2,x3,x4,x5,x6 <= 2
+	//    //Objective function to be minimised
+	//    function y=f(x)
+	//		y=0
+	//		for i =1:6
+	//			y=y+sin(x(i));
+	//		end	
+	//	endfunction
+	//	//Variable bounds  
+	//	x1 = [-2, -2, -2, -2, -2, -2];
+	//  x2 = [2, 2, 2, 2, 2, 2];
+  //  intcon = [2 3 4]
+	//	//Options
+	//	options=list("MaxIter",[1500],"CpuTime", [100])
+	//	[x,fval] =intfminbnd(f ,intcon, x1, x2, options)
+  // // Press ENTER to continue
+	//
+	// Examples
+	//	//Find x in R such that it minimizes:
+	//    //f(x)= 1/x^2
+	//	//0 <= x <= 1000
+	//    //Objective function to be minimised
+	//    function y=f(x)
+	//		   y=1/x^2;
+	//	  endfunction
+	//	//Variable bounds  
+	//	x1 = [0];
+	//  x2 = [1000];
+  //  intcon = [1];
+	//	[x,fval,exitflag,output,lambda] =intfminbnd(f,intcon , x1, x2)
+  // // Press ENTER to continue
+	//
+	// Examples
+	//    //The below problem is an unbounded problem:
+	//	//Find x in R^2 such that it minimizes:
+	//    //f(x)= -[(x1-1)^2 + (x2-1)^2]
+	//	//-inf <= x1,x2 <= inf
+	//    //Objective function to be minimised
+	//    function y=f(x)
+	// 		y=-((x(1)-1)^2+(x(2)-1)^2);
+	//	endfunction
+	//	//Variable bounds  
+	//	x1 = [-%inf , -%inf];
+	//  x2 = [ %inf , %inf];
+	//	//Options
+	//	options=list("MaxIter",[1500],"CpuTime", [100])
+	//	[x,fval,exitflag,output,lambda] =intfminbnd(f,intcon, x1, x2, options)  
+	// Authors
+	// Harpreet Singh
+
+	//To check the number of input and output arguments
+ 	[lhs , rhs] = argn();
+	
+	//To check the number of arguments given by the user
+ 	if ( rhs<4 | rhs>5 ) then
+  		errmsg = msprintf(gettext("%s: Unexpected number of input arguments : %d provided while should be int [4 5] "), "intfminbnd", rhs);
+  		error(errmsg);
+ 	end
+ 
+	//Storing the Input Parameters  
+ 	fun = varargin(1);
+ 	intcon = varargin(2);	
+ 	x1 = varargin(3);
+ 	x2 = varargin(4);
+  nbvar = size(x1,"*");
+
+  param = list();
+  //To check whether options has been entered by user   
+  if ( rhs>=5  ) then
+      param =varargin(5);
+  end
+
+  //To check whether the Input arguments
+  Checktype("intfminbnd", fun, "fun", 1, "function");
+  Checktype("intfminbnd", intcon, "intcon", 2, "constant");
+  Checktype("intfminbnd", x1, "x1", 3, "constant");
+  Checktype("intfminbnd", x2, "x2", 4, "constant");
+  Checktype("intfminbnd", param, "options", 5, "list");  
+
+
+  if(nbvar==0) then
+    errmsg = msprintf(gettext("%s: x1 cannot be an empty"), "intfminbnd");
+    error(errmsg);    
+  end
+
+  ///////////////// To check vectors ///////////////// 
+  Checkvector("intfminbnd", x1, "x1", 3, nbvar)
+  x1 = x1(:);
+  Checkvector("intfminbnd", x2, "x2", 4, nbvar)
+  x2 = x2(:);
+  Checkvector("intfminbnd", intcon, "intcon", 2, size(intcon,"*"))
+  intcon = intcon(:);
+
+  if(~isequal(size(x1),size(x2))) then
+    errmsg = msprintf(gettext("%s: x1 and x2 should be of same size"), "intfminbnd");
+    error(errmsg);
+  end
+
+  for i=1:size(intcon,1)
+      if(intcon(i)>nbvar) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be less than the number of variables"), "intfminbnd");
+        error(errmsg);
+      end
+
+      if (intcon(i)<0) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be greater than 0 "), "intfminbnd");
+        error(errmsg);
+      end
+
+      if(modulo(intcon(i),1)) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be an integer "), "intfminbnd");
+        error(errmsg);
+      end
+  end   
+  
+options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian',"off")
+
+  //Pushing param into default value
+  
+  for i = 1:(size(param))/2
+    select convstr(param(2*i-1),'l')
+      case 'integertolerance' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(2) = param(2*i);
+      case 'maxnodes' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(4) = options(2*i);
+      case 'cputime' then 
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(6) = options(2*i);
+      case 'allowablegap' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(8) = options(2*i);
+      case 'maxiter' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(10) = options(2*i);
+      case 'gradobj' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "string");
+        if(convstr(options(2*i),'l') == "on") then
+          options(12) = "on"
+        elseif(convstr(options(2*i),'l') == "off") then
+          options(12) = "off"
+        else
+          error(999, 'Unknown string passed in gradobj.');
+        end
+      case 'hessian' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "string");
+        if(convstr(options(2*i),'l') == "on") then
+          options(14) = "on";
+        elseif(convstr(options(2*i),'l') == "off") then
+          options(14) = "off";
+        else
+          error(999, 'Unknown string passed in hessian.');
+        end
+      else
+        error(999, 'Unknown string argument passed.');
+    end
+  end 
+
+  ///////////////// Functions Check /////////////////
+
+  //To check the match between f (1st Parameter) and x1 (2nd Parameter)
+  if(execstr('init=fun(x1)','errcatch')==21) then
+    errmsg = msprintf(gettext("%s: Objective function and x1 did not match"), "intfminbnd");
+    error(errmsg);
+  end
+
+  if(options(12) == "on") then
+      if(execstr('[grad_y,grad_dy]=fun(x1)','errcatch')==59) then
+        errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfminbnd");
+        error(errmsg);
+      end
+      Checkvector("intfminbnd_options", grad_dy, "dy", 12, nbvar);
+  end
+
+  if(options(14) == "on") then
+      if(execstr('[hessian_y,hessian_dy,hessian]=fun(x1)','errcatch')==59) then
+        errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfminbnd");
+        error(errmsg);
+      end
+
+      if ( ~isequal(size(hessian) == [nbvar nbvar]) ) then
+        errmsg = msprintf(gettext("%s: Size of hessian should be nbvar X nbvar"), "intfminbnd");
+        error(errmsg);
+      end
+  end
+
+  //Converting the User defined Objective function into Required form (Error Detectable)
+  function [y,check] = _f(x)
+    try
+      y=fun(x)
+      [y,check] =  checkIsreal(y)
+    catch
+      y=0;
+      check=1;
+    end
+   endfunction
+    
+  //Defining a function to calculate Hessian if the respective user entry is OFF 
+  function [hessy,check]=_gradhess(x)
+    if (options(14) == "on") then
+      try
+        [obj,dy,hessy] = fun(x)
+        [hessy,check] =  checkIsreal(hessy)
+      catch
+        hessy = 0;
+        check=1;
+      end
+    else
+      try
+        [dy,hessy]=numderivative(fun,x)
+        [hessy,check] =  checkIsreal(hessy)
+      catch
+        hessy=0;
+        check=1;
+      end
+    end
+  endfunction
+    
+   //Defining an inbuilt Objective gradient function 
+    function [dy,check] = _gradf(x) 
+      if (options(12) =="on") then
+        try
+          [y,dy]=fun(x)
+          [dy,check] =  checkIsreal(dy)
+        catch
+          dy = 0;
+          check=1;
+        end
+      else
+          try 
+            dy=numderivative(fun,x)
+            [dy,check] =  checkIsreal(dy)
+          catch
+            dy=0;
+          check=1;
+          end
+      end
+    endfunction
+    
+    intconsize = size(intcon,"*");
+
+	[xopt,fopt,exitflag] = inter_fminbnd(_f,_gradf,_gradhess,x1,x2,intcon,options,nbvar);
+
+    //In the cases of the problem not being solved, return NULL to the output matrices
+    if( exitflag~=0 & exitflag~=3 ) then
+      gradient = [];
+      hessian = [];
+    else
+      [ gradient, hessian] = numderivative(_f, xopt, [], [], "blockmat");
+    end
+
+    //To print output message
+    select exitflag
+    
+    case 0 then
+        printf("\nOptimal Solution Found.\n");
+    case 1 then
+        printf("\nInFeasible Solution.\n");
+    case 2 then
+        printf("\nnObjective Function is Continuous Unbounded.\n");
+    case 3 then
+        printf("\Limit Exceeded.\n");
+    case 4 then
+        printf("\nUser Interrupt.\n");
+    case 5 then
+        printf("\nMINLP Error.\n");
+    else
+        printf("\nInvalid status returned. Notify the Toolbox authors\n");
+        break;
+    end
+endfunction
+
+function [y, check] = checkIsreal(x)
+  if ((~isreal(x))) then
+    y = 0
+    check=1;
+  else
+        y = x;
+    check=0;
+  end 
+endfunction
diff --git a/build/Scilab/intfmincon.sci b/build/Scilab/intfmincon.sci
new file mode 100644
index 0000000..9cf9116
--- /dev/null
+++ b/build/Scilab/intfmincon.sci
@@ -0,0 +1,501 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// 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
+// Author: Harpreet Singh, Pranav Deshpande and Akshay Miterani
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+function [xopt,fopt,exitflag,gradient,hessian] = intfmincon (varargin)
+  // Solves a constrainted multi-variable mixed integer non linear programming problem
+  //
+  //   Calling Sequence
+  //   xopt = intfmincon(f,x0,intcon,A,b)
+  //   xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq)
+  //   xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub)
+  //   xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub,nlc)
+  //   xopt = intfmincon(f,x0,intcon,A,b,Aeq,beq,lb,ub,nlc,options)
+  //   [xopt,fopt] = intfmincon(.....)
+  //   [xopt,fopt,exitflag]= intfmincon(.....)
+  //   [xopt,fopt,exitflag,gradient]=intfmincon(.....)
+  //   [xopt,fopt,exitflag,gradient,hessian]=intfmincon(.....)
+	//
+	//   Parameters
+	//   f : a function, representing the objective function of the problem 
+  //   x0 : a vector of doubles, containing the starting values of variables. 
+  //   intcon : a vector of integers, represents which variables are constrained to be integers
+  //   A : a matrix of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b. 
+  //   b : a vector of double, represents the linear coefficients in the inequality constraints A⋅x ≤ b.
+  //   Aeq : a matrix of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq.
+  //   beq : a vector of double, represents the linear coefficients in the equality constraints Aeq⋅x = beq.
+  //   lb : Lower bounds, specified as a vector or array of double. lb represents the lower bounds elementwise in lb ≤ x ≤ ub.
+  //   ub : Upper bounds, specified as a vector or array of double. ub represents the upper bounds elementwise in lb ≤ x ≤ ub.
+  //   nlc : a function, representing the Non-linear Constraints functions(both Equality and Inequality) of the problem. It is declared in such a way that non-linear inequality constraints are defined first as a single row vector (c), followed by non-linear equality constraints as another single row vector (ceq). Refer Example for definition of Constraint function.
+  //   options : a list, containing the option for user to specify. See below for details. 
+  //   xopt : a vector of doubles, containing the the computed solution of the optimization problem.
+  //   fopt : a scalar of double, containing the the function value at x.
+  //   exitflag : a scalar of integer, containing the flag which denotes the reason for termination of algorithm. See below for details.
+  //   gradient : a vector of doubles, containing the Objective's gradient of the solution.
+  //   hessian  : a matrix of doubles, containing the Objective's hessian of the solution.
+  //
+	//   Description
+	//   Search the minimum of a multi-variable function on bounded interval specified by :
+	//   Find the minimum of f(x) such that 
+	//
+	//   <latex>
+	//    \begin{eqnarray}
+	//    &\mbox{min}_{x}
+	//    & f(x)\\
+	//    & \text{subject to} & x1 \ < x \ < x2 \\
+	//    \end{eqnarray}
+	//   </latex>
+	//
+	//   The routine calls Bonmin for solving the Bounded Optimization problem, Bonmin is a library written in C++.
+	//
+	// The options allows the user to set various parameters of the Optimization problem. 
+	// It should be defined as type "list" and contains the following fields.
+	// <itemizedlist>
+	//   <listitem>Syntax : options= list("IntegerTolerance", [---], "MaxNodes",[---], "MaxIter", [---], "AllowableGap",[---] "CpuTime", [---],"gradobj", "off", "hessian", "off" );</listitem>
+  //   <listitem>IntegerTolerance : a Scalar, a number with that value of an integer is considered integer..</listitem>
+  //   <listitem>MaxNodes : a Scalar, containing the Maximum Number of Nodes that the solver should search.</listitem>
+	//   <listitem>CpuTime : a Scalar, containing the Maximum amount of CPU Time that the solver should take.</listitem>
+	//   <listitem>AllowableGap : a Scalar, to stop the tree search when the gap between the objective value of the best known solution is reached.</listitem>
+  //   <listitem>MaxIter : a Scalar, containing the Maximum Number of Iteration that the solver should take.</listitem>
+  //   <listitem>gradobj : a string, to turn on or off the user supplied objective gradient.</listitem>
+  //   <listitem>hessian : a Scalar, to turn on or off the user supplied objective hessian.</listitem>
+	//   <listitem>Default Values : options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian',"off")</listitem>
+	// </itemizedlist>
+	//
+	// The exitflag allows to know the status of the optimization which is given back by Ipopt.
+	// <itemizedlist>
+	//   <listitem>exitflag=0 : Optimal Solution Found </listitem>
+	//   <listitem>exitflag=1 : Maximum Number of Iterations Exceeded. Output may not be optimal.</listitem>
+	//   <listitem>exitflag=2 : Maximum CPU Time exceeded. Output may not be optimal.</listitem>
+	//   <listitem>exitflag=3 : Stop at Tiny Step.</listitem>
+	//   <listitem>exitflag=4 : Solved To Acceptable Level.</listitem>
+	//   <listitem>exitflag=5 : Converged to a point of local infeasibility.</listitem>
+	// </itemizedlist>
+	//
+	// For more details on exitflag see the Bonmin documentation, go to http://www.coin-or.org/Bonmin
+  //
+	// Examples
+	//	//Find x in R^6 such that it minimizes:
+	//    //f(x)= sin(x1) + sin(x2) + sin(x3) + sin(x4) + sin(x5) + sin(x6)
+	//	//-2 <= x1,x2,x3,x4,x5,x6 <= 2
+	//    //Objective function to be minimised
+	//    function y=f(x)
+	//		y=0
+	//		for i =1:6
+	//			y=y+sin(x(i));
+	//		end	
+	//	endfunction
+	//	//Variable bounds  
+	//	x1 = [-2, -2, -2, -2, -2, -2];
+	//  x2 = [2, 2, 2, 2, 2, 2];
+  //  intcon = [2 3 4]
+	//	//Options
+	//	options=list("MaxIter",[1500],"CpuTime", [100])
+	//	[x,fval] =intfmincon(f ,intcon, x1, x2, options)
+  // // Press ENTER to continue
+	//
+	// Examples
+	//	//Find x in R such that it minimizes:
+	//    //f(x)= 1/x^2
+	//	//0 <= x <= 1000
+	//    //Objective function to be minimised
+	//    function y=f(x)
+	//		   y=1/x^2;
+	//	  endfunction
+	//	//Variable bounds  
+	//	x1 = [0];
+	//  x2 = [1000];
+  //  intcon = [1];
+	//	[x,fval,exitflag,output,lambda] =intfmincon(f,intcon , x1, x2)
+  // // Press ENTER to continue
+	//
+	// Examples
+	//    //The below problem is an unbounded problem:
+	//	//Find x in R^2 such that it minimizes:
+	//    //f(x)= -[(x1-1)^2 + (x2-1)^2]
+	//	//-inf <= x1,x2 <= inf
+	//    //Objective function to be minimised
+	//    function y=f(x)
+	// 		y=-((x(1)-1)^2+(x(2)-1)^2);
+	//	endfunction
+	//	//Variable bounds  
+	//	x1 = [-%inf , -%inf];
+	//  x2 = [ %inf , %inf];
+	//	//Options
+	//	options=list("MaxIter",[1500],"CpuTime", [100])
+	//	[x,fval,exitflag,output,lambda] =intfmincon(f,intcon, x1, x2, options)  
+	// Authors
+	// Harpreet Singh
+
+	//To check the number of input and output arguments
+ 	[lhs , rhs] = argn();
+	
+	//To check the number of arguments given by the user
+ 	if ( rhs<4 | rhs>11 ) then
+  		errmsg = msprintf(gettext("%s: Unexpected number of input arguments : %d provided while should be int [4 5] "), "intfmincon", rhs);
+  		error(errmsg);
+ 	end
+ 
+	//Storing the Input Parameters  
+ 	fun = varargin(1);
+ 	x0     = varargin(2);
+  intcon = varargin(3); 
+  A      = varargin(4);
+  b      = varargin(5);
+  Aeq    = [];
+  beq    = [];
+  lb       = [];
+  ub       = [];
+  nlc      = [];
+    
+  if (rhs>5) then
+    Aeq    = varargin(6);
+    beq    = varargin(7);
+  end
+
+  if (rhs>7) then
+    lb       = varargin(8);
+    ub       = varargin(9);
+  end
+
+  if (rhs>9) then
+    nlc      = varargin(10);
+  end
+
+  param = list();
+  //To check whether options has been entered by user   
+  if ( rhs>  10) then
+      param =varargin(11);
+  end
+
+  //To check whether the Input arguments
+  Checktype("intfmincon", fun, "fun", 1, "function");
+  Checktype("intfmincon", x0, "x0", 2, "constant");
+  Checktype("intfmincon", intcon, "intcon", 3, "constant");
+  Checktype("intfmincon", A, "A", 4, "constant");
+  Checktype("intfmincon", b, "b", 5, "constant");
+  Checktype("intfmincon", Aeq, "Aeq", 6, "constant");
+  Checktype("intfmincon", beq, "beq", 7, "constant");
+  Checktype("intfmincon", lb, "lb", 8, "constant");
+  Checktype("intfmincon", ub, "ub", 9, "constant");
+  Checktype("intfmincon", nlc, "nlc", 10, ["constant","function"]);
+  Checktype("intfmincon", param, "options", 11, "list");  
+
+
+  nbVar = size(x0,"*");
+  if(nbVar==0) then
+    errmsg = msprintf(gettext("%s: x0 cannot be an empty"), "intfmincon");
+    error(errmsg);    
+  end
+
+  if(size(lb,"*")==0) then
+    lb = repmat(-%inf,nbVar,1);
+  end
+
+  if(size(ub,"*")==0) then
+    ub = repmat(%inf,nbVar,1);
+  end
+
+  //////////////// To Check linear constraints /////////
+
+  //To check for correct size of A(3rd paramter)
+  if(size(A,2)~=nbVar & size(A,2)~=0) then
+    errmsg = msprintf(gettext("%s: Expected Matrix of size (No of linear inequality constraints X No of Variables) or an Empty Matrix for Linear Inequality Constraint coefficient Matrix A"), solver_name);
+    error(errmsg);
+  end
+  nbConInEq=size(A,"r");
+
+  //To check for the correct size of Aeq (5th paramter)
+  if(size(Aeq,2)~=nbVar & size(Aeq,2)~=0) then
+    errmsg = msprintf(gettext("%s: Expected Matrix of size (No of linear equality constraints X No of Variables) or an Empty Matrix for Linear Equality Constraint coefficient Matrix Aeq"), solver_name);
+    error(errmsg);
+  end
+  nbConEq=size(Aeq,"r");
+
+  ///////////////// To check vectors ///////////////// 
+
+  Checkvector("intfmincon", x0, "x0", 2, nbVar);
+  x0 = x0(:);
+  if(size(intcon,"*")) then
+    Checkvector("intfmincon", intcon, "intcon", 3, size(intcon,"*"))
+    intcon = intcon(:);
+  end
+  if(nbConInEq) then
+    Checkvector("intfmincon", b, "b", 5, nbConInEq);
+    b = b(:);
+  end
+  if(nbConEq) then
+    Checkvector("intfmincon", beq, "beq", 7, nbConEq);
+    beq = beq(:);
+  end
+  Checkvector("intfmincon", lb, "lb", 8, nbVar);
+  lb = lb(:);
+  
+  Checkvector("intfmincon", ub, "ub", 9, nbVar);
+  ub = ub(:);
+
+  /////////////// To check integer //////////////////////
+  for i=1:size(intcon,1)
+      if(intcon(i)>nbVar) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be less than the number of variables"), "intfmincon");
+        error(errmsg);
+      end
+
+      if (intcon(i)<0) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be greater than 0 "), "intfmincon");
+        error(errmsg);
+      end
+
+      if(modulo(intcon(i),1)) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be an integer "), "intfmincon");
+        error(errmsg);
+      end
+  end
+  
+options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian',"off",'gradcon',"off")
+
+  //Pushing param into default value
+  
+  for i = 1:(size(param))/2
+    select convstr(param(2*i-1),'l')
+      case 'integertolerance' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(2) = param(2*i);
+      case 'maxnodes' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(4) = param(2*i);
+      case 'cputime' then 
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(6) = param(2*i);
+      case 'allowablegap' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(8) = param(2*i);
+      case 'maxiter' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(10) = param(2*i);
+      case 'gradobj' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "string");
+        if(convstr(options(2*i),'l') == "on") then
+          options(12) = "on"
+        elseif(convstr(options(2*i),'l') == "off") then
+          options(12) = "off"
+        else
+          error(999, 'Unknown string passed in gradobj.');
+        end
+      case 'hessian' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "function");
+        options(14) = param(2*i);
+      case 'GradCon' then
+        Checktype("intfmincon_options", param(2*i), param(2*i-1), 2*i, "string");
+        if(convstr(options(2*i),'l') == "on") then
+          options(16) = "on"
+        elseif(convstr(options(2*i),'l') == "off") then
+          options(16) = "off"
+        else
+          error(999, 'Unknown string passed in gradcon.');
+        end
+      else    
+        error(999, 'Unknown string argument passed.');
+    end
+  end 
+
+  ///////////////// Functions Check /////////////////
+
+  //To check the match between f (1st Parameter) and x0 (2nd Parameter)
+  if(execstr('init=fun(x0)','errcatch')==21) then
+    errmsg = msprintf(gettext("%s: Objective function and x0 did not match"), "intfmincon");
+    error(errmsg);
+  end
+
+  if(options(12) == "on") then
+       if(execstr('[grad_y,grad_dy]=fun(x1)','errcatch')==59) then
+        errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfmincon");
+        error(errmsg);
+      end
+      Checkvector("intfmincon_options", grad_dy, "dy", 12, nbVar);
+  end
+
+  if(options(14) == "on") then
+      if(execstr('[hessian_y,hessian_dy,hessian]=fun(x1)','errcatch')==59) then
+        errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfmincon");
+        error(errmsg);
+      end
+
+      if ( ~isequal(size(hessian) == [nbVar nbVar]) ) then
+        errmsg = msprintf(gettext("%s: Size of hessian should be nbVar X nbVar"), "intfmincon");
+        error(errmsg);
+      end
+  end
+
+  numNlic = 0;
+  numNlec = 0;
+  numNlc = 0;
+
+  if (type(nlc) == 13 | type(nlc) == 11) then    
+      if(execstr('[sample_c,sample_ceq] = nlc(x0)','errcatch')==21) then
+        errmsg = msprintf(gettext("%s: Non-Linear Constraint function and x0 did not match"), solver_name);
+        error(errmsg);
+      end
+      numNlic = size(sample_c,"*");
+      numNlec = size(sample_ceq,"*");
+      numNlc = no_nlic + no_nlec;
+  end
+
+  /////////////// Creating conLb and conUb ////////////////////////
+
+  conLb = [repmat(-%inf,nbConInEq,1);beq;repmat(-%inf,numNlic,1);repmat(0,numNlic,1);]
+  conUb = [b;beq;repmat(0,numNlic,1);repmat(0,numNlic,1);]
+
+  //Converting the User defined Objective function into Required form (Error Detectable)
+  function [y,check] = _f(x)
+    try
+      y=fun(x)
+      [y,check] =  checkIsreal(y)
+    catch
+      y=0;
+      check=1;
+    end
+   endfunction
+    
+   //Defining an inbuilt Objective gradient function 
+    function [dy,check] = _gradf(x) 
+      if (options(12) =="on") then
+        try
+          [y,dy]=fun(x)
+          [dy,check] =  checkIsreal(dy)
+        catch
+          dy = 0;
+          check=1;
+        end
+      else
+          try 
+            dy=numderivative(fun,x)
+            [dy,check] =  checkIsreal(dy)
+          catch
+            dy=0;
+          check=1;
+          end
+      end
+    endfunction
+
+    function [y,check] = _addnlc(x)
+    x= x(:);
+    c=[]
+    ceq = [];
+      try
+        if(type(nlc) == 13 & numNlc~=0) then
+          {
+            [c,ceq] = nlc(x);
+          }
+        end
+        ylin = [A*x;Aeq*x];
+        y = [ylin;c(:);ceq(:)];
+        [y,check] = checkIsreal(y)
+      catch
+        y=0;
+        check=1;
+      end
+    endfunction
+
+    //Defining an inbuilt Objective gradient function 
+    function [dy,check] = _gradnlc(x) 
+      if (options(16) =="on") then
+        try
+          [y,dy]=_addnlc(x)
+          [dy,check] = checkIsreal(dy)
+        catch
+          dy = 0;
+          check=1;
+        end
+      else
+          try
+            dy=numderivative(_addnlc,x)
+            [dy,check] = checkIsreal(dy)
+          catch
+            dy=0;
+            check=1;
+          end
+      end
+    endfunction
+
+  //Defining a function to calculate Hessian if the respective user entry is OFF 
+  function [hessy,check]=_gradhess(x,obj_factor,lambda)
+    if (type(options(14)) == "function") then
+      try
+        [obj,dy,hessy] = fun(x,obj_factor,lambda)
+        [hessy,check] =  checkIsreal(hessy)
+      catch
+        hessy = 0;
+        check=1;
+      end
+    else
+      try
+        [dy,hessfy]=numderivative(_f,x,%eps^(1/3),1,"blockmat");
+        hessny = []
+        if(type(nlc) == 13 & numNlc~=0) then
+        {
+          [dy,hessny] = numderivative(_addnlc,x,%eps^(1/3),1,"blockmat");
+        }
+        end
+        hessianc = []
+          for i = 1:numNlc
+                    hessianc = hessianc + lambda(i)*hessny((i-1)*nbVar+1:nbVar*i,:)
+          end
+        hessy = obj_factor*hessfy + hessianc;
+        [hessy,check] =  checkIsreal(hessy)
+      catch
+        hessy=0;
+        check=1;
+      end
+    end
+  endfunction
+
+    intconsize = size(intcon,"*");
+
+	[xopt,fopt,exitflag] = inter_fmincon(_f,_gradf,_addnlc,_gradnlc,_gradhess,x0,lb,ub,conLb,conUb,intcon,options,nbConInEq+nbConEq);
+
+    //In the cases of the problem not being solved, return NULL to the output matrices
+    if( exitflag~=0 & exitflag~=3 ) then
+      gradient = [];
+      hessian = [];
+    else
+      [ gradient, hessian] = numderivative(_f, xopt, [], [], "blockmat");
+    end
+
+    //To print output message
+    select exitflag
+    
+    case 0 then
+        printf("\nOptimal Solution Found.\n");
+    case 1 then
+        printf("\nInFeasible Solution.\n");
+    case 2 then
+        printf("\nObjective Function is Continuous Unbounded.\n");
+    case 3 then
+        printf("\Limit Exceeded.\n");
+    case 4 then
+        printf("\nUser Interrupt.\n");
+    case 5 then
+        printf("\nMINLP Error.\n");
+    else
+        printf("\nInvalid status returned. Notify the Toolbox authors\n");
+        break;
+    end
+endfunction
+
+function [y, check] = checkIsreal(x)
+  if ((~isreal(x))) then
+    y = 0
+    check=1;
+  else
+        y = x;
+    check=0;
+  end 
+endfunction
diff --git a/build/Scilab/intfminunc.sci b/build/Scilab/intfminunc.sci
new file mode 100644
index 0000000..5141017
--- /dev/null
+++ b/build/Scilab/intfminunc.sci
@@ -0,0 +1,351 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// 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
+// Author: Harpreet Singh, Pranav Deshpande and Akshay Miterani
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+function [xopt,fopt,exitflag,gradient,hessian] = intfminunc (varargin)
+	// Solves an unconstrainted multi-variable mixed integer non linear programming optimization problem
+	//
+	//   Calling Sequence
+	//   xopt = intfminunc(f,x0)
+	//   xopt = intfminunc(f,x0,intcon)
+	//   xopt = intfminunc(f,x0,intcon,options)
+	//   [xopt,fopt] = intfminunc(.....)
+	//   [xopt,fopt,exitflag]= intfminunc(.....)
+	//   [xopt,fopt,exitflag,gradient,hessian]= intfminunc(.....)
+	//
+	//   Parameters
+	//   f : a function, representing the objective function of the problem 
+	//   x0 : a vector of doubles, containing the starting of variables.
+	//	 intcon : a vector of integers, represents which variables are constrained to be integers
+	//   options: a list, containing the option for user to specify. See below for details.
+	//   xopt : a vector of doubles, the computed solution of the optimization problem.
+	//   fopt : a scalar of double, the function value at x. 
+	//   exitflag : a scalar of integer, containing the flag which denotes the reason for termination of algorithm. See below for details.
+  //   gradient : a vector of doubles, containing the Objective's gradient of the solution.
+  //   hessian  : a matrix of doubles, containing the Objective's hessian of the solution.
+	//
+	//   Description
+	//   Search the minimum of a multi-variable mixed integer non linear programming unconstrained optimization problem specified by :
+	//   Find the minimum of f(x) such that 
+	//
+	//   <latex>
+	//    \begin{eqnarray}
+	//    &\mbox{min}_{x}
+	//    & f(x)
+  //    & x_i \in \!\, \mathbb{Z}, i \in \!\, I
+	//    \end{eqnarray}
+	//   </latex>
+	//
+	//   The routine calls Bonmin for solving the Un-constrained Optimization problem, Bonmin is a library written in C++.
+	//
+	// The options allows the user to set various parameters of the Optimization problem. 
+	// It should be defined as type "list" and contains the following fields.
+	// <itemizedlist>
+	//   <listitem>Syntax : options= list("IntegerTolerance", [---], "MaxNodes", [---], "CpuTime", [---], "AllowableGap", [---], "MaxIter", [---]);</listitem>
+	//   <listitem>IntegerTolerance : a Scalar, containing the Integer tolerance value that the solver should take.</listitem>
+	//   <listitem>MaxNodes : a Scalar, containing the maximum nodes that the solver should make.</listitem>
+	//	 <listitem>MaxIter : a Scalar, containing the Maximum Number of Iteration that the solver should take.</listitem>
+	//   <listitem>AllowableGap : a Scalar, containing the allowable gap value that the solver should take.</listitem>
+	//   <listitem>CpuTime : a Scalar, containing the Maximum amount of CPU Time that the solver should take.</listitem>
+  //   <listitem>gradobj : a string, to turn on or off the user supplied objective gradient.</listitem>
+  //   <listitem>hessian : a Scalar, to turn on or off the user supplied objective hessian.</listitem>
+  //   <listitem>Default Values : options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian',"off")</listitem>
+  // </itemizedlist>
+	// </itemizedlist>
+	//
+	// The exitflag allows to know the status of the optimization which is given back by Bonmin.
+	// <itemizedlist>
+	//   <listitem>exitflag=0 : Optimal Solution Found. </listitem>
+	//   <listitem>exitflag=1 : InFeasible Solution.</listitem>
+	//   <listitem>exitflag=2 : Output is Continuous Unbounded.</listitem>
+	//   <listitem>exitflag=3 : Limit Exceeded.</listitem>
+	//   <listitem>exitflag=4 : User Interrupt.</listitem>
+	//   <listitem>exitflag=5 : MINLP Error.</listitem>
+	// </itemizedlist>
+	//
+	// For more details on exitflag see the Bonmin page, go to http://www.coin-or.org/Bonmin
+	//
+	// Examples
+	//     //Find x in R^2 such that it minimizes the Rosenbrock function 
+	//     //f = 100*(x2 - x1^2)^2 + (1-x1)^2
+	//     //Objective function to be minimised
+	//     function y= f(x)
+	//   	    y= 100*(x(2) - x(1)^2)^2 + (1-x(1))^2;
+	//     endfunction
+	//	 //Starting point  
+	//     x0=[-1,2];
+  //     intcon = [2]
+	//     //Options
+	//     options=list("MaxIter", [1500], "CpuTime", [500]);
+	//     //Calling 
+	//     [xopt,fopt,exitflag,gradient,hessian]=intfminunc(f,x0,intcon,options)
+  // // Press ENTER to continue
+	//
+	// Examples
+	//      //Find x in R^2 such that the below function is minimum
+	//      //f = x1^2 + x2^2
+	//      //Objective function to be minimised
+	//      function y= f(x)
+	//   	     y= x(1)^2 + x(2)^2;
+	//      endfunction
+	//	  //Starting point  
+	//      x0=[2,1];
+  //      intcon = [1];  
+	//      [xopt,fopt]=intfminunc(f,x0,intcon)
+  // // Press ENTER to continue
+	//
+	// Examples
+	//     //The below problem is an unbounded problem:
+	//     //Find x in R^2 such that the below function is minimum
+	//     //f = - x1^2 - x2^2
+	//     //Objective function to be minimised
+	//     function [y,g,h] = f(x)
+	//        y = -x(1)^2 - x(2)^2;
+  //        g = [-2*x(1),-2*x(2)];
+  //        h = [-2,0;0,-2];
+	//     endfunction
+	//	 //Starting point  
+	//     x0=[2,1];
+  //     intcon = [1]
+  //     options = list("gradobj","ON","hessian","on");
+	//    [xopt,fopt,exitflag,gradient,hessian]=intfminunc(f,x0,intcon,options)
+
+	//To check the number of input and output arguments
+   	[lhs , rhs] = argn();
+	
+	//To check the number of arguments given by the user
+   	if ( rhs<2 | rhs>4 ) then
+    		errmsg = msprintf(gettext("%s: Unexpected number of input arguments : %d provided while should be int [2 3 4] "), "intfminunc", rhs);
+    		error(errmsg);
+   	end
+ 
+	//Storing the 1st and 2nd Input Parameters  
+   	fun = varargin(1);
+   	x0 = varargin(2);
+   //To add intcon
+   intcon=[];
+   if ( rhs >=3 ) then
+			intcon = varargin(3);
+	end
+
+  param = list();
+  //To check whether options has been entered by user   
+ 	if ( rhs>=4  ) then
+      param =varargin(4);
+ 	end
+  
+  nbvar = size(x0,"*");
+
+  ///////////////// To check whether the Input arguments /////////////////
+  Checktype("intfminunc", fun, "fun", 1, "function");
+  Checktype("intfminunc", x0, "x0", 2, "constant");
+  Checktype("intfminunc", intcon, "intcon", 3, "constant");
+  Checktype("intfminunc", param, "options", 4, "list");  
+  
+  ///////////////// To check x0 ///////////////// 
+  Checkvector("intfminunc", x0, "x0", 2, nbvar)
+  x0 = x0(:);
+  Checkvector("intfminbnd", intcon, "intcon", 3, size(intcon,"*"))
+  intcon = intcon(:);
+
+  //Error Checks for intcon 
+  for i=1:size(intcon,1)
+      if(intcon(i)>nbvar) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be less than the number of variables"), "intfminunc");
+        error(errmsg);
+      end
+
+      if (intcon(i)<0) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be greater than 0 "), "intfminunc");
+        error(errmsg);
+      end
+
+      if(modulo(intcon(i),1)) then
+        errmsg = msprintf(gettext("%s: The values inside intcon should be an integer "), "intfminunc");
+        error(errmsg);
+      end
+  end
+   
+  //If options has been entered, then check whether an even number of entires has been entered   
+  if (modulo(size(param),2)) then
+    errmsg = msprintf(gettext("%s: Size of parameters should be even"), "intfminunc");
+    error(errmsg);
+  end 
+   
+  intconSize = length(intcon);
+  
+  options = list('integertolerance',1d-06,'maxnodes',2147483647,'cputime',1d10,'allowablegap',0,'maxiter',2147483647,'gradobj',"off",'hessian', "off")
+
+  //Pushing param into default value
+  
+  for i = 1:(size(param))/2
+    select convstr(param(2*i-1),'l')
+      case 'integertolerance' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(2) = param(2*i);
+      case 'maxnodes' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(4) = options(2*i);
+      case 'cputime' then 
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(6) = options(2*i);
+      case 'allowablegap' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(8) = options(2*i);
+      case 'maxiter' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "constant");
+        options(10) = options(2*i);
+      case 'gradobj' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "string");
+        if(convstr(param(2*i),'l') == "on") then
+          options(12) = "on"
+        elseif(convstr(param(2*i),'l') == "off") then
+          options(12) = "off"
+        else
+          error(999, 'Unknown string passed in gradobj.');
+        end
+      case 'hessian' then
+        Checktype("intfminbnd_options", param(2*i), param(2*i-1), 2*i, "string");
+        if(convstr(param(2*i),'l') == "on") then
+          options(14) = "on";
+        elseif(convstr(param(2*i),'l') == "off") then
+          options(14) = "off";
+        else
+          error(999, 'Unknown string passed in hessian.');
+        end
+      else
+        error(999, 'Unknown string argument passed.');
+    end
+  end 
+
+  ///////////////// Functions Check /////////////////
+
+  //To check the match between fun (1st Parameter) and x0 (2nd Parameter)
+  if(execstr('init=fun(x0)','errcatch')==21) then
+    errmsg = msprintf(gettext("%s: Objective function and x0 did not match"), "intfminunc");
+    error(errmsg);
+  end
+
+  if(options(12) == "on") then
+    
+      if(execstr('[grad_y,grad_dy]=fun(x0)','errcatch')==59) then
+        errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfminunc");
+        error(errmsg);
+      end
+
+      Checkvector("intfminunc_options", grad_dy, "dy", 12, nbvar);
+  end
+
+  if(options(14) == "on") then
+    
+      if(execstr('[hessian_y,hessian_dy,hessian]=fun(x0)','errcatch')==59) then
+        errmsg = msprintf(gettext("%s: Gradient of objective function is not provided"), "intfminunc");
+        error(errmsg);
+      end
+
+      if ( ~isequal(size(hessian),[nbvar nbvar]) ) then
+        errmsg = msprintf(gettext("%s: Size of hessian should be nbvar X nbvar"), "intfminunc");
+        error(errmsg);
+      end
+  end
+
+  //Converting the User defined Objective function into Required form (Error Detectable)
+ 	function [y,check] = _f(x)
+ 		try
+      y=fun(x)
+      [y,check] =  checkIsreal(y)
+	  catch
+		  y=0;
+		  check=1;
+	  end
+   endfunction
+    
+   //Defining an inbuilt Objective gradient function 
+    function [dy,check] = _gradf(x) 
+      if (options(12) =="on") then
+        try
+          [y,dy]=fun(x);
+          [dy,check] =  checkIsreal(dy);
+        catch
+          dy = 0;
+          check=1;
+        end
+      else
+        try 
+          dy=numderivative(fun,x);
+          [dy,check] =  checkIsreal(dy);
+        catch
+          dy=0;
+          check=1;
+        end
+      end
+    endfunction
+
+  //Defining a function to calculate Hessian if the respective user entry is OFF 
+  function [hessy,check]=_gradhess(x)
+    if (options(14) == "on") then
+      try
+        [obj,dy,hessy] = fun(x)
+        [hessy,check] =  checkIsreal(hessy)
+      catch
+        hessy = 0;
+        check=1;
+      end
+    else
+      try
+        [dy,hessy]=numderivative(fun,x)
+        [hessy,check] =  checkIsreal(hessy)
+      catch
+        hessy=0;
+        check=1;
+      end
+    end
+  endfunction
+
+    //Calling the bonmin function for solving the above problem
+	  [xopt,fopt,exitflag] = inter_fminunc(_f,_gradf,_gradhess,x0,intcon,options,intconSize,nbvar);
+
+  	//In the cases of the problem not being solved, return NULL to the output matrices
+  	if( exitflag~=0 & exitflag~=3 ) then
+  		gradient = [];
+        hessian = [];
+    else
+      [ gradient, hessian] = numderivative(_f, xopt, [], [], "blockmat");
+  	end
+
+    //To print output message
+    select exitflag
+        case 0 then
+            printf("\nOptimal Solution Found.\n");
+        case 1 then
+            printf("\nInFeasible Solution.\n");
+        case 2 then
+            printf("\nObjective Function is Continuous Unbounded.\n");
+        case 3 then
+            printf("\Limit Exceeded.\n");
+        case 4 then
+            printf("\nUser Interrupt.\n");
+        case 5 then
+            printf("\nMINLP Error.\n");
+        else
+            printf("\nInvalid status returned. Notify the Toolbox authors\n");
+            break;
+    end
+endfunction
+
+function [y, check] = checkIsreal(x)
+	if ((~isreal(x))) then
+		y = 0
+		check=1;
+	else
+        y = x;
+		check=0;
+	end	
+endfunction