Example 1

     function Banana(Pars: TVec;const Consts: Array of TSample;const PConsts: Array of TObject): TSample;
     begin
      Result := 100*Sqr(Pars[1]-Sqr(Pars[0]))+Sqr(1-Pars[0]);
     end;
     procedure GradBanana(Fun: TRealFunction; Pars: TVec; const Consts: Array of TSample; const ObjConsts: Array of TObject; Grad: TVec);
     begin
	    Grad.Values[0] := -400*(Pars[1]-Sqr(Pars[0]))*Pars[0]-2*(1-Pars[0]);
	    Grad.Values[1] := 200*(Pars[1]-Sqr(Pars[0]));
     end;

     procedure TForm1.FormCreate(Sender: TObject);
     begin
      MtxOptim.VariableParameters.SetIt(false,[2,-1]);
      MtxOptim.RealFunction := Banana;
      MtxOptim.OptimizationMethod := optBFGS;
      // use exact gradient vector calculation
      // NOTE : set MtxOptim.GradProcedure to nil if yo
	    //        want to use internal numeric gradient calculation
      MtxOptim.GradProcedure := GradBanana;
      MtxOptim.Recalculate;
     end;

    #include "MtxVecCpp.h" //MtxVecCPP.cpp must be included in the project
    #include "Math387.hpp"
    #include "Optimization.hpp"
    #include "MtxIntDiff.hpp"
    #include "MtxVecTools.hpp"

    // Objective function
    double __fastcall Banana(TVec * Parameters, const double * Constants, const int Constants_Size,
     System::TObject* const * ObjConst, const int ObjConst_Size)
    {
      double* Pars = Parameters->PValues1D(0);

      return 100.0*IntPower(Pars[1]-IntPower(Pars[0],2),2)+IntPower(1.0-Pars[0],2);
    }
    // Analytical gradient of the objective function
    void __fastcall GradBanana(TRealFunction Fun, TVec * Parameters, const double * Consts, const int Consts_Size,
      System::TObject* const * ObjConst, const int PConsts_Size, Mtxvec::TVec* Grad)
    {
      double* Pars = Parameters->PValues1D(0);

      Grad->Values[0] = -400*(Pars[1]-IntPower(Pars[0],2))*Pars[0] - 2*(1-Pars[0]);
      Grad->Values[1] = 200*(Pars[1]-IntPower(Pars[0],2));
    }

    void __fastcall TForm1::FormCreate(TObject *Sender)
    {
      MtxOptim->VariableParameters->SetIt(false,OPENARRAY(TSample,(2,-1)));
      MtxOptim->RealFunction = Banana;
      MtxOptim.OptimizationMethod = optBFGS;
      // use exact gradient vector calculation
      // NOTE : set MtxOptim.GradProcedure to NULL if you
	    //        want to use internal numeric gradient calculation
      MtxOptim->GradProcedure = GradBanana;
      MtxOptim->Recalculate();

    }

    using Dew.Math;
    using Dew.Math.Units;

    namespace Dew.Examples
    {
      // Objective function
      double Banana(TVec pars, double[] consts, object[] obj)
      {
          return 100.0*Math387.IntPower(pars[1]- Math387.IntPower(pars[0],2),2)
            + Math387.IntPower(1.0-pars[0],2);
      }

      // Analytical gradient of the objective function
      void GradBanana(TRealFunction Fun, TVec pars, double[] consts, object[] obj, TVec grad)
      {
        grad.Values[0] = -400*(pars[1]-Math387.IntPower(pars[0],2))*pars[0] - 2*(1-pars[0]);
        grad.Values[1] = 200*(pars[1]-Math387.IntPower(pars[0],2));
      }

      private void Example(TMtxOptimization opt)
      {
        opt.VariableParameters.SetIt(new double[] {2,-1});
        opt.RealFunction = Banana;
        opt.OptimizationMethod = TOptimizationMethod.optBFGS;
        // use exact gradient vector calculation
        // NOTE : set opt.GradProcedure to null if you
	      //        want to use internal numeric gradient calculation
        opt.GradProcedure = GradBanana;
        opt.Recalculate();
      }
    }