clann_real_type
ilpso_compute_probability_of_mutation(struct ilpso *s)
{
clann_real_type v = 0,
f_avg = 0,
f_max = 0,
f[s->number_of_particles];
unsigned int i;
for (i = 0; i < s->number_of_particles; i++)
{
f[i] = s->f_fitness(s->problem,
clann_matrix_value(&s->positions, i, 0));
f_avg += f[i];
}
f_avg /= s->number_of_particles;
for (i = 0; i < s->number_of_particles; i++)
f_max = (abs(f[i] - f_avg) > f_max) ? abs(f[i] - f_avg) : 1;
for (i = 0; i < s->number_of_particles; i++)
v += CLANN_POW((f[i] - f_avg) / f_max, 2);
return v / s->number_of_particles;
}
void
som_initialize(struct som *ann,
som_grid_type grid_type,
clann_size_type input_size,
clann_size_type width)
{
ann->input_size = input_size;
ann->grid.width = width;
ann->learning_rate = 0.1;
ann->const_1 = 1000 / CLANN_LOG(ann->grid.width);
ann->const_2 = 1000;
ann->step = 1;
ann->epoch = 1;
ann->grid.type = grid_type;
switch (ann->grid.type)
{
case SOM_GRID_LINE:
ann->grid.dimension = SOM_GRID_1D;
break;
case SOM_GRID_SQUARE:
ann->grid.dimension = SOM_GRID_2D;
break;
case SOM_GRID_CUBE:
ann->grid.dimension = SOM_GRID_3D;
}
/*
* Compute the number of neurons and initialize weights
*/
ann->grid.n_neurons = CLANN_POW(ann->grid.width, ann->grid.dimension);
matrix_initialize(&ann->grid.indexes,
ann->grid.n_neurons,
ann->grid.dimension);
matrix_initialize(&ann->grid.weights,
ann->grid.n_neurons,
ann->input_size);
matrix_fill_rand(&ann->grid.weights, -1, 1);
/*
* Generate the indexes
*/
clann_size_type count = 0;
clann_real_type *buffer;
buffer = malloc(sizeof(clann_real_type) * ann->grid.dimension);
som_grid_indexes(ann, 0, buffer, &count);
free(buffer);
}
clann_real_type
metric_norm(const clann_real_type *a,
const unsigned int length)
{
clann_real_type sum = 0;
unsigned int i;
for (i = 0; i < length; i++)
sum += CLANN_POW(a[i], 2);
return CLANN_SQRT(sum);
}
