parsetask.sci

基于SCILAB的The Genetic Algorithm Toolbox for SCILAB (GATS)工具箱

function [x,endPop,bPop,traceInfo,pareto] = ParseTask(Taskfile, startPop)
global Population;          	// population number
global Bounds;              	// variable bounds          
global Constraints;         	// variable constraints                           
global EvalFuns;				// Evaluation functions
global TermPara;              	// terminate function name                 
global TermFun;             	// terminate parameters    
global Coding;              	// Coding                             
global SelectMeth;          	// select function name                           
global SelectPara           	// select function parameters                     
global XoverMeth            	// crossover function name                        
global XoverPara            	// crossover function parameters                  
global MutateMeth           	// mutate function name                           
global MutatePara           	// mutate function parameters                     
global AdjSelectMeth;       	// select parameters adjust function name         
global AdjSelectPara;       	// select parameters adjust function parameters   
global AdjXoverMeth;        	// crossover parameters adjust function name      
global AdjXoverPara;        	// crossover parameters adjust function parameters
global AdjMutateMeth;       	// mutate parameters adjust function name         
global AdjMutatePara;       	// mutate parameters adjust function parameters   
global FitScalingMeth;      	// fitness Scaling function name                  
global FitScalingPara       	// fitness Scaling function parameters            
global ClusterNicheMeth     	// cluster niching function name                  
global ClusterNichePara     	// cluster niching function parameters            
global ShareNicheMeth       	// share niching function name                    
global ShareNichePara			// share niching function parameters              
global ElitistReserve			// best reserve                    
global ExtElitistReserve        // extended best reserve           
global ElitistNonDup            // no duplication when reserve best
global ExtElitistReservePara    // extended best reserve parameters
global CrsGenEliRes             // cross generation best reserve   
global TaskList;				// subtask taskfile               
global TaskPopu;                // subtask population             
global PopUsed;                 // population used by subtask
global InformCollect;           // whether collect runing information
global InitializePop;           // whether initialize population  
global ParallelSubTask;			// whether run subtask on parallel 
global ParallelEvaluation;		// whether evaluation on pararllel
global ParallelEvalNum;         // number of parallel process     
global DispMeth;				// display function name        
global DispPara;                // display function parameters  
global user_stop				// whether user stop process

global UG_SYS_DIR UG_USER_DIR 

// initialize variable
Population=-1;
Bounds=[];
Constraints = list();
EvalFuns=list();
TermPara=100;
TermFun='';
CodeMeth='';
SelectMeth='';
SelectPara='';
XoverMeth='';
XoverPara='';
MutateMeth='';
MutatePara='';
FitScalingMeth='';
FitScalingPara='';
ClusterNicheMeth='';
ClusterNichePara='';
ShareNicheMeth='';
ShareNichePara='';
AdjSelectMeth = '';
AdjSelectPara = '';
AdjXoverMeth = '';
AdjXoverPara = '';
AdjMutateMeth = '';
AdjMutatePara = '';
ElitistReserve=1;
ExtElitistReserve=0;
ElitistNonDup=0;
ExtElitistReservePara=0;
CrsGenEliRes=0;
TaskList=list();
TaskPopu=[];
PopUsed=0;
InformCollect = 1;
InitializePop = 0;
DispMeth = '';
DispPara = '';
user_stop = 0;
ParallelSubTask = 0;
ParallelEvaluation = 0;
ParallelEvalNum = 0;

// get functions
	getf(UG_SYS_DIR+'/basic/b2f.sci');
	getf(UG_SYS_DIR+'/basic/calcbits.sci');
	getf(UG_SYS_DIR+'/basic/delta.sci');
	getf(UG_SYS_DIR+'/basic/Distance.sci');
	getf(UG_SYS_DIR+'/basic/File2Fun.sci');
	getf(UG_SYS_DIR+'/basic/gray2f.sci');
	getf(UG_SYS_DIR+'/basic/initializega.sci');
	getf(UG_SYS_DIR+'/basic/InitPareto.sci');
	getf(UG_SYS_DIR+'/basic/matfuns.sci');
	getf(UG_SYS_DIR+'/basic/maxGenTerm.sci');
	getf(UG_SYS_DIR+'/basic/MultiEvaluate.sci');
	getf(UG_SYS_DIR+'/basic/normDistance.sci');
	getf(UG_SYS_DIR+'/basic/parse.sci');
	getf(UG_SYS_DIR+'/basic/ParseTask.sci');
	getf(UG_SYS_DIR+'/basic/ReadTask.sci');
	getf(UG_SYS_DIR+'/basic/shuffle.sci');

	getf(UG_SYS_DIR+'/universalga.sci');

// get content of task file
	fid = mopen(Taskfile, 'r');
	if ( fid == -1), return, end;
	content=mgetl(fid);
	mclose(fid)

// parse the content of task file
i=1;
while i<=size(content,1)
    tline = content(i,:);
    while ( length(tline) == 0 )
    	i = i + 1;
	if ( i > size(content,1) )
		break;
	end    	
    	tline = content(i,:);
    end

    c = parse(tline);		// parse a line to 3 word

    select stripblanks(c(1,:))
    case 'Popu:'					// population setting
        if (stripblanks(c(2,:)) == 'init')
            InitializePop = 1;
            Population =  sscanf (c(3,:),'%d');
        end;
        if (stripblanks(c(2,:)) == 'inherit')
            InitializePop = 0;
        end;
    case 'Bounds:'					// variable bounds setting
        Bounds = eval(c(2,:));
        if (size(Bounds,2) == 2),Bounds(:,3)=1e-6;end;
    case 'Coding:'					// Coding setting
        Coding = stripblanks(c(2,:));
    case 'Constraints:'					// variable constraints setting
        j=size(Constraints);
        Constraints(j+1) = list(stripblanks(c(2,:)),  c(3,:));
    case 'EvalFun:'					// Evaluation functions setting
        j=size(EvalFuns);
        EvalFuns(j+1) = list(stripblanks(c(2,:)),  eval(c(3,:)));
    case 'ParallelEvaluation:'					// Evaluation on parallel setting
        ParallelEvaluation =1;
        ParallelEvalNum = eval(c(2,:));
        if (ParallelEvalNum <= 0)
        	ParallelEvaluation = 0;
        	ParallelEvalNum = 0;
        end
    case 'CycleBegin:'					// ga main cycle begin
        TermFun = stripblanks(c(2,:));
        TermPara=stripblanks(c(3,:));
        i=i+1;
        tline = stripblanks(content(i,:));
        while ~(tline == 'End')			// ga main cycle end
            fc = parse(tline);
            select stripblanks(fc(1,:))
            case 'Select:'					// select function setting
                SelectMeth = stripblanks(fc(2,:));
                SelectPara = fc(3,:);
            case 'Crossover:'					// crossover function setting
                XoverMeth = stripblanks(fc(2,:));
                XoverPara = fc(3,:);
            case 'Mutation:'					// mutate function setting
                MutateMeth = stripblanks(fc(2,:));
                MutatePara = fc(3,:);
            case 'FitScaling:'					// fitscaling function setting
                FitScalingMeth=stripblanks(fc(2,:));
                FitScalingPara = fc(3,:);
            case 'ClusterNiche:'					// cluster niche function setting
                ClusterNicheMeth = stripblanks(fc(2,:));
                ClusterNichePara = fc(3,:);
            case 'ShareNiche:'					// share niche function setting
                ShareNicheMeth = stripblanks(fc(2,:));
                ShareNichePara = fc(3,:);
            case 'ElitistReserve:'					// best reserve setting
                if ( stripblanks(fc(2,:)) == 'on' )
                    ElitistReserve = 1;
                else
                    ElitistReserve = 0;
                end;
            case 'ExtElitistReserve:'					// extended best reserve setting
                ExtElitistReserve = 1;
                ElitistReserve = 0;
                ExtElitistReservePara = stripblanks(fc(2,:));
                if ( size(fc,1)==3 )
                    if (stripblanks(fc(3,:)) == ('NonDuplication'))
                        ElitistNonDup=1;
                    else
                        ElitistNonDup=0;
                    end
                end
            case 'CrossGenerationElitistReserve:'		// cross generation best reserve setting
                if (stripblanks(fc(2,:)) == 'on' )
                    CrsGenEliRes = 1;
                    ElitistReserve = 0;
                else
                    CrsGenEliRes = 0;
                end;
            case 'ParallelSubTask:'					// whether run subtask on parallel setting
                if (stripblanks(fc(2,:)) == 'on' )
                    ParallelSubTask = 1;
                else
                    ParallelSubTask = 0;
                end;
            case 'Task:'					// subtask setting
                temp = stripblanks(fc(3,:));
                l = length(temp);
                a=part(temp,l);
                if ( a == '%' ) 
                    ThesePop = Population * sscanf (part(temp,[1:l]),'%d')/100;
                else
                    ThesePop =  sscanf (fc(3,:),'%d'); 
                end;
                if ( ThesePop + PopUsed > Population )
                    disp('error: summary of subtask''s Population is bigger than main task''s');
                else
                    l = size(TaskList);
                    TaskList(l+1) = fc(2,:);
                    TaskPopu = [TaskPopu;PopUsed+1,PopUsed + ThesePop];
                    PopUsed = PopUsed + ThesePop;
                end;
            else            
                disp('Error: unrecognizable symbol!');
                disp(fc(1,:));
                break;
            end        
            i=i+1;
            tline = stripblanks(content(i,:));
        end
    case 'InformCollect:'					// whether collect running information setting
        if (stripblanks(c(2,:)) == 'on')
            InformCollect=1;
        else
            InformCollect=0;
        end
    case 'AdjustSelect:'					// select parameter adjust function setting
        AdjSelectMeth=stripblanks(c(2,:));
        AdjSelectPara=c(3,:);
    case 'AdjustXover:'						// crossover parameter adjust function setting
        AdjXoverMeth=stripblanks(c(2,:));
        AdjXoverPara=c(3,:);
    case 'AdjustMutate:'					// mutate parameter adjust function setting
        AdjMutateMeth=stripblanks(c(2,:));
        AdjMutatePara=c(3,:);
    case 'Display:'							// Display function setting
        DispMeth=stripblanks(c(2,:));
        DispPara=c(3,:);
    case ''									// empty line
        
    else 
        break;
    end
    i=i+1;
        
end

// set codetype
if strcmp(stripblanks(Coding),'Binary'),codetype=0;end;
if strcmp(stripblanks(Coding),'Real'),  codetype=1;end;
if strcmp(stripblanks(Coding),'Order'), codetype=2;end;
if strcmp(stripblanks(Coding),'Gray'),  codetype=3;end;

// initialize population
if InitializePop
    startPop=initializega(Population,Bounds,[codetype]);
end;

opts=[codetype];
isRunning=1;

// initialize user_stop
TK_SetVar('user_stop','0');

// set taskname
TaskName = [];
for i=1:size(TaskList)
    TaskName = [TaskName;TaskList(i)];
end


// construct parameters of universalga
popu_paras = list(Bounds, Constraints, Population, opts, startPop);
	main_meth = list(SelectMeth, SelectPara, XoverMeth, XoverPara, MutateMeth, MutatePara);
	adjust_meth = list(AdjSelectMeth, AdjSelectPara, AdjXoverMeth, AdjXoverPara, AdjMutateMeth, AdjMutatePara);
	other_meth = list(FitScalingMeth, FitScalingPara, ClusterNicheMeth, ClusterNichePara, ShareNicheMeth, ShareNichePara);
	reserve_meth = list(ElitistReserve, ExtElitistReserve, ElitistNonDup, ExtElitistReservePara, CrsGenEliRes);
meth_paras = list(main_meth, adjust_meth, other_meth, reserve_meth);
cycle_paras = list(EvalFuns, TermFun, TermPara, InformCollect,ParallelEvaluation,ParallelEvalNum);
subtask_paras = list(TaskName, TaskPopu, ParallelSubTask);
interactive_paras = list(DispMeth,DispPara);

// call universalga
[x,endPop,bPop,traceInfo,pareto] = universalga(popu_paras, meth_paras, cycle_paras, subtask_paras, interactive_paras);