/* MAIN */
int main(int argc, char** argv) {
srand(time(NULL));
particle particles[P_NUM];
float global_best[SPACE_DIM];
// Set shifted origin to some place
for(int i=0; i<SPACE_DIM; ++i)
shifted_origin[i] = 83;
// Init every particle
for(int i=0; i<P_NUM; ++i)
particles_init(particles[i]);
for(int i=0; i<COMPUTATIONS; ++i) {
for(int pos=0; pos<P_NUM; ++pos) {
for(int direction=0; direction<SPACE_DIM; ++direction) {
// Compute new position with damping if needed
particles[pos].position[direction] = particles[pos].position[direction] + particles[pos].vel[direction];
if(particles[pos].position[direction] < 100 || particles[pos].position[direction] > 100) {
float damping_rand = (float)rand() / (float)RAND_MAX;
particles[pos].vel[direction] = -damping_rand * particles[pos].vel[direction];
}
// Compute new velocity
float r1 = (float)rand() / (float)RAND_MAX;
float r2 = (float)rand() / (float)RAND_MAX;
particles[pos].vel[direction] = INERTIA*particles[pos].vel[direction] +
r1 * C_SOC * (global_best[direction] - particles[pos].position[direction]) +
r2 * C_SOC * (particles[pos].personal_best[direction] - particles[pos].position[direction]);
// Limit velocity
if(particles[pos].vel[direction] > MAX_VEL)
particles[pos].vel[direction] = MAX_VEL;
else if(particles[pos].vel[direction] < -MAX_VEL)
particles[pos].vel[direction] = -MAX_VEL;
// If needed, update personal and global best
if (f01(particles[pos].position) < f01(particles[pos].personal_best))
for(int k=0; k<SPACE_DIM; ++k)
particles[pos].personal_best[k] = particles[pos].position[k];
if (f01(particles[pos].position) < f01(global_best))
for(int k=0; k<SPACE_DIM; ++k)
global_best[k] = particles[pos].position[k];
}
}
}
std::cout << "Global best : " << f01(global_best) << std::endl;
std::cout << "Global optimum : (";
for (int i=0; i<SPACE_DIM; ++i) {
std::cout << global_best[i];
if(i!=SPACE_DIM-1)
std::cout << ", ";
}
std::cout << ")" << std::endl;
return 0;
}
int main (void) {
int z = f01(f00(),f00());
assert(z == 7);
return 1;
}
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
if (Size < 4) return 0;
// Spoof the counters.
for (int i = 0; i < 200; i++) {
f23();
f12();
f01();
}
memcpy(t, t0, sizeof(t));
t[(unsigned)'a'] = f01;
t[Data[0]]();
t[Data[1]]();
t[Data[2]]();
t[Data[3]]();
return 0;
}
void test01 ( )
/******************************************************************************/
/*
Purpose:
TEST01 tests BISECTION_RC, evaluating the function in a separate routine.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
14 January 2013
Author:
John Burkardt
*/
{
double a;
double b;
double dx;
double dx_tol;
double fx;
double fx_tol;
int it;
int it_max;
int job;
double x;
printf ( "\n" );
printf ( "TEST01\n" );
printf ( " Demonstrate BISECTION_RC on a simple example.\n" );
printf ( " The function is evaluated in a separate routine.\n" );
fx_tol = 1.0E-08;
dx_tol = 1.0E-06;
it = 0;
it_max = 30;
a = 0.0;
b = 1.0;
fx = 0.0;
job = 0;
printf ( "\n" );
printf ( " I X FX DX\n" );
printf ( "\n" );
for ( ; ; )
{
x = bisection_rc ( &a, &b, fx, &job );
if ( job < 0 )
{
printf ( "\n" );
printf ( " Error return.\n" );
break;
}
it = it + 1;
fx = f01 ( x );
if ( it <= 2 )
{
dx = fabs ( b - a );
}
else
{
dx = 0.5 * fabs ( b - a );
}
printf ( " %4d %14.6g %14.6g %14.6g\n", it, x, fx, dx );
if ( fabs ( fx ) <= fx_tol )
{
printf ( "\n" );
printf ( " Function is small.\n" );
break;
}
if ( dx <= dx_tol )
{
printf ( "\n" );
printf ( " Interval is tiny.\n" );
break;
}
if ( it_max <= it )
{
printf ( "\n" );
printf ( " Reached iteration limit.\n" );
break;
}
}
printf ( "\n" );
printf ( " A = %14.6g, F(A) = %14.6g\n", a, f01 ( a ) );
printf ( " X = %14.6g, F(X) = %14.6g\n", x, f01 ( x ) );
printf ( " B = %14.6g, F(B) = %14.6g\n", b, f01 ( b ) );
return;
}
