_evec3v2.pas

微分进化法的pascal程序

program devec3;

{* About devec3                                                   *}
{* Differential Evolution for MATLAB                              *}
{* Copyright (C) 1996, 1997 R. Storn                              *}
{* International Computer Science Institute (ICSI)                *}
{* 1947 Center Street, Suite 600                                  *}
{* Berkeley, CA 94704                                             *}
{* E-mail: [e-mail]                                *}
{* WWW:    http://www.icsi.berkeley.edu/~storn/                   *}
{* Translated into Pascal by Hubert Geldon [e-mail]          *}
{*                           and                                  *}
{*                           Piotr A. Gauden [e-mail] *}
{*                           N. Copernicus Univ.                  *}
{*                           Department of Chemistry              *}
{*                           87-100 Torun                         *}

{$IFDEF CPU87}
{$N+}
uses crt , printer, graph;
     type real = extended;

{$ELSE}
uses crt , printer;
{$ENDIF}


{ Include definitions and declarations }
{$I d:\dysk_13\decl.de }

{ Include procedures and functions for generating random }
{$I d:\dysk_13\genps.de }

{ Include procedures and functions for calculating DC }
{$I d:\dysk_13\deter.de }




{############################################################################}
BEGIN           {* main program *}

clrscr;
assign(res,'d:\result.txt');
assign(xs,'d:\dysk_13\x.txt');
assign(ys,'d:\dysk_13\y.txt');
rewrite(res);




writeln('Enter the elements of vector of lower bounds XVmin.');
for i := 1 to D do
    readln(XVmin[1,i]);

writeln('Enter the elements of vector of upper bounds XVmax.');
for i := 1 to D do
    readln(XVmax[1,i]);

repeat
   begin
      writeln('Enter seed random number (0.000 ... 1.000).');
      readln(randomseed);
   end;
until (randomseed>0) and (randomseed<1.0);
warmup_random(randomseed);

{* pop is a matrix of size NPxD. It will be initialized with random values *}
{* between the min and max values of the parameters *}
for i := 1 to NP do
    for j := 1 to D do
        begin
          randtest:=rand;
          pop[i,j] := XVmin[1,j] + (randtest * (XVmax[1,j] - XVmin[1,j]));
        end;

{* Evaluate the best member after initialization *}
reset(xs);
reset(ys);
readln(xs,FDX);
readln(ys,FDY);
if FDX <> FDY then
   begin
      writeln('Number of data points in data files is different. Correct it.');
      halt;
   end;
if FDX <> XY then
   begin
      writeln('Number of data points in data files is different then XY value');
      writeln('in "const" part of program. Correct it.');
      halt;
   end;
for datnum := 1 to XY do
   begin
      readln(xs,xdata[datnum]);
      readln(ys,ydata[datnum]);
   end;
close(xs);
close(ys);

cur_gen := 1;
sqall := 0.0;

n_pop := 1;                        {* check the first member *}
DC:=Determination(n_pop);
memberval[1] := odch_st;
bestval := odch_st;
for i := 1 to D do
    bestmemiter[1,i] := pop[1,i];  {* check the first member *}


for j := 2 to NP do		   {* check the rest of members *}
    begin
       n_pop := j;
       DC:=Determination(n_pop);
       memberval[j] := odch_st;
       if memberval[j] < bestval  then
          begin
            bestval := memberval[j];
            for k := 1 to D do
                bestmemiter[1,k] := pop[j,k];
          end;
    end;

for k := 1 to D do
    bestmem[1,k] := bestmemiter[1,k];  {* best member ever, after first generation *}
    bestvalev := bestval;          {* check the rest of members *}

writeln(res,'---------------------------------------------------');
writeln(res);
writeln(res,'  Generation:   ',1,'.');
writeln(res);
for i := 1 to NP do
    begin
       write(res,i,'.  [');
       begin
          for j := 1 to D - 1 do
              write(res,pop[i,j],' ');
       end;
       writeln(res,pop[i,D],' ],  value: ',memberval[i]);
    end;
writeln(res);
write(res,'  Best member:  ');
write(res,'[ ');
for j := 1 to D - 1 do
    write(res,bestmem[1,j],' ');
writeln(res,bestmem[1,D],' ]');
writeln(res,'  Value of best member ever:  ',bestvalev);
writeln(res);
writeln(res,'---------------------------------------------------');

writeln;
write('Generation   1:      Best member ever: [');
for j := 1 to D - 1 do
    write(bestmem[1,j],' ');
writeln(bestmem[1,D],' ]');


cur_gen := 2;
while cur_gen <= itermax do
   begin
      for i := 1 to NP do
          for j := 1 to D do
              popold[i,j] := pop[i,j];      {* save the old population *}

{%%%%%% ind}
      for i := 1 to 4 do
          begin
             randmatrix[i] := rand;
             randmatrixint[i] := i;
          end;
      for j := 1 to 4 do
          begin
             valmin := 1.0;
             for i := 1 to 4 do
	         begin
                    if randmatrix[i] < valmin
                    then
                      begin
                         valmin := randmatrix[i];
                         ind[j] := randmatrixint[i] {* shuffle locations of vectors *}
                      end;
                 end;
             for k := 1 to 4 do
                 begin
                    if randmatrix[k] = valmin
                    then randmatrix[k] := 1;
                 end;
          end;
{%%%%%% ind}

{%%%%%% rot}
          for i := 1 to NP do
              rot[i] := i-1;
{%%%%%% rot}

{%%%%%% a1}
      for i := 1 to NP do
          begin
             randmatrixnp[i] := rand;
             randmatrixnpint[i] := i;
          end;
      for j := 1 to NP do
          begin
             valmin := 1.0;
             for i := 1 to NP do
	         begin
                    if randmatrixnp[i] < valmin
                    then
                      begin
                         valmin := randmatrixnp[i];
                         a1[j] := randmatrixnpint[i]; {* shuffle locations of vectors *}
                      end;
                 end;
             for k := 1 to NP do
                 begin
                    if randmatrixnp[k] = valmin
                    then randmatrixnp[k] := 1;
                 end;
          end;
{%%%%%% a1}

{%%%%%% a2}
          for i := 1 to NP do
              begin
                 transmata[i] := rot[i] + ind[1];
                 tempmata[i]  := transmata[i]/NP;
                 rt[i]  := trunc(tempmata[i]);
                 rt[i]  := transmata[i] - NP * rt[i]; {* rotate indices by ind[1] position *}
              end;

        for i := 1 to NP do
              begin
                 k := rt[i] + 1;
                 a2[i] := a1[k];    {* rotate vector locations *}
              end;
{%%%%%% a2}

{%%%%%% a3}
          for i := 1 to NP do
              begin
                 transmata[i] := rot[i] + ind[2];
                 tempmata[i]  := transmata[i]/NP;
                 rt[i]  := trunc(tempmata[i]);
                 rt[i]  := transmata[i] - NP * rt[i]; {* rotate indices by ind[1] position *}
              end;
          for i := 1 to NP do
              begin
                 k := rt[i] + 1;
                 a3[i] := a2[k];
              end;
{%%%%%% a3}

{%%%%%% a4}
          for i := 1 to NP do
              begin
                 transmata[i] := rot[i] + ind[3];
                 tempmata[i]  := transmata[i]/NP;
                 rt[i]  := trunc(tempmata[i]);
                 rt[i]  := transmata[i] - NP * rt[i]; {* rotate indices by ind[1] position *}
              end;
          for i := 1 to NP do
              begin
                 k := rt[i] + 1;
                 a4[i] := a3[k];
              end;
{%%%%%% a4}

{%%%%%% a5}
          for i := 1 to NP do
              begin