0.5 0.5 2.9 0.1
3 999 3 3 999 1
6
0
0 3 2
 0 0
0
0 0 5
0

0.5 0.5 2.9 0.1
3 3 20 20 20 1
2
0
0 3 2
 0 0
0
0 0 0
0


0.5 0.5 2.9 0.1
3 999 3 3 999 1
 0
0
0 3 2
0 0
0
0 0 5
0


Model1 for "normal" PSO
Model2 for recursive PSO (when you use PSO to optimize a Model1 parameter set,

on a given set of problems)

<alpha_max> <alpha_min> (b_max> <b_min>
 <hood_min> <hood_max> <init_size (swarm)> <min_size> <max_size (swarm)>  <selection type> 
<freedom degree> 
<gener_type>
 <init_type> <H (search space type)> <confinement type>
 (parallel> <local_search>
 <max number of rehope>
<move_type> <queen> <guided_rand>
<rand_type>

Some explanations
------------------

<hood_min> minimum neighbourhood size. 
           Particular value: if equal to zero => the neighbourhood is always the whole swarm.

selection type (cf PSO() )
0   no real selection. The bad particle is just "merged" into the best neighbour
*1   try to remove the bad particle


freedom degree  (cf move_particle() )
*0   same coefficient beta for all dimensions
1   same coeff beta, partly random,for all dimensions
2   same coeff beta,more random, for all dimensions
3   partly random beta for each dimension
4   more random beta for each dimension
5   random "around" adaptive b
6	independent dimensions (option in progress)

<gener_type> (only for coloring problem (see add_particle() )
0 => according to init_type
1 => special generation 

init_type (only for coloring problem)
0 => random
i => generate a position/coloring using method number i (cf init_particle_color() )

H  (only for coloring problem)
0 => all colorings
1 => all admissible colorings (all constraints are respected). (Too) powerful algo
2 => just the min number of colors (but constraints are not necessarily respected)
3 => at each time step, change the kind of projection (minimize constraints <=> minimize colors)


Note: solution space = H1 inter H2

confinement type (only for coloring problem) (cf constrain() and  admissible_color() )
for H1:
0 => quick algo, not very powerful
1 => quite quick algo, quite powerful 
*2 => usually more powerful algo, but also longer
3 => try 1 and 2 and keep the best position
4 => try a _less_ powerful algo (minimize_constrain() )
5 => try a _less_ powerful algo (protein folding) 

for H2:
any positive value => minimize_color()

for H3
any positive value => alternatively "minimize constraints <=> minimize colors"



NOTE: to directly solve easy problems at initialisation, use H=1 and confinement=2 or3




parallel
0 => sequential (cyclic) mode
1 => simulating parallel mode

local_search
0 => no local search
i => local search type i (cf. color_local_search() and auto_move() )
*3


Cf. also hard coded parameters:
option, in color_3
parallel, in color_8_1


move_type
< 2  =>  classical move, using the best neighbour
2    => try also the self-move (just using its own velocity, not taken any neighbour into account)
        and keep the best

queen
1 => use local queens, 0 else

guided_rand
n => use guided random generation with n intervals for each dimension

rand_type
0 => classical rand function
1 => pseudorandom numbers are read from a file (rand_list.txt)
2 => chaos