refac: library-friendly symbols

diff --git a/Makefile b/Makefile
index db23bb6e71c98afe4647c942b80279476d347603..fc8ebcbbdfe6327624fea317d8a57e2f78d54658 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -7,8 +7,7 @@ install-bin: compile_flags executable
 
 install-lib: compile_flags lib
        mv libcgo.a /usr/local/lib
 
 install-lib: compile_flags lib
        mv libcgo.a /usr/local/lib

-       mkdir -p /usr/local/include/cgo
-       cp include/* /usr/local/include/cgo
+       cp include/cgo.h /usr/local/include

 
 #compile_flags_gtk:
 #      echo "-Iinclude `pkg-config --cflags gtk4` -lm -fopenmp `pkg-config --libs gtk4`" | perl -pe 's|(-.*?)\s|\1\n|g' > compile_flags.txt
 
 #compile_flags_gtk:
 #      echo "-Iinclude `pkg-config --cflags gtk4` -lm -fopenmp `pkg-config --libs gtk4`" | perl -pe 's|(-.*?)\s|\1\n|g' > compile_flags.txt

diff --git a/include/cgo.h b/include/cgo.h
new file mode 100644 (file)
index 0000000..792d0d2
--- /dev/null
+++ b/include/cgo.h
@@ -0,0 +1,25 @@
+typedef struct {
+  int dim;
+  int particlec;
+  double *sample_range_min;
+  double *sample_range_max;
+  double (*f)(double*);  // fitness function
+  double cr;             // crossover probability = .9
+  double dw;             // differential weight   = .8
+} cgo_de_parameters;
+
+typedef struct {
+  int dim;
+  int particlec;
+  double *sample_range_min;
+  double *sample_range_max;
+  double (*f)(double*);  // fitness function
+  double eps;            // convergence tolerance
+  double w;              // inertia
+  double c;              // cognitive factor
+  double s;              // social factor
+} cgo_pso_parameters;
+
+void cgo_de(cgo_de_parameters *par, double *res);
+void cgo_pso(cgo_pso_parameters *par, double *res);
+

diff --git a/include/de.h b/include/de.h
deleted file mode 100644 (file)
index 57c4a8c..0000000
--- a/include/de.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "rand.h"
-
-typedef struct {
-  int dim;
-  int particlec;
-  range *rrange;
-  double (*f)(double*);  // fitness function
-  double cr;             // crossover probability = .9
-  double dw;             // differential weight   = .8
-} de_parameters;
-
-void de_optimize(de_parameters *par, double *res);

diff --git a/include/pso.h b/include/pso.h
deleted file mode 100644 (file)
index b888dbe..0000000
--- a/include/pso.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "rand.h"
-
-typedef struct particle particle;
-
-typedef struct {
-  double *x;
-  double fitness;
-} particle_state;
-
-typedef struct {
-  int dim;
-  int particlec;
-  range *rrange;
-  double (*f)(double*);  // fitness function
-  double eps;            // convergence tolerance
-  double w;              // inertia
-  double c;              // cognitive factor
-  double s;              // social factor
-} pso_parameters;
-
-typedef struct {
-  particle *particles;
-  particle *global_best;
-} swarm;
-
-struct particle {
-  particle_state current;
-  particle_state best;
-  double *velocity;
-};
-
-void swarm_alloc(pso_parameters *par, swarm *sw);
-void swarm_free(pso_parameters *par, swarm *sw);
-void swarm_populate(pso_parameters *par, swarm *sw, const range *rrange);
-void swarm_velocity_update(pso_parameters *par, swarm *sw);
-void pso_optimize(pso_parameters *par, particle_state *res);

diff --git a/include/rand.h b/include/rand.h
index 172d6947654e4ccc9a04d260894f2d79409f1a34..654ff180505e1d1df405c1129f0e016082749bf5 100644 (file)
--- a/include/rand.h
+++ b/include/rand.h
@@ -1,13 +1,8 @@
 #ifndef RAND_H
 #define RAND_H
 
 #ifndef RAND_H
 #define RAND_H
 

-typedef struct {
-  double min;
-  double max;
-} range;
-

 double rands();
 double randrange(double min, double max);
 double rands();
 double randrange(double min, double max);

-void vec_pick(const int dim, const range *rrange, double *v);
+void vec_pick(const int dim, const double *min, const double *max, double *v);

 
 #endif
 
 #endif

diff --git a/include/vector.h b/include/vector.h
index 7e7160ab2831dc3dc9c76d1329778c07cb89ca33..613497c86a14806271cb8999e7429bc4028a9182 100644 (file)
--- a/include/vector.h
+++ b/include/vector.h
@@ -1,3 +1,6 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+

 double *vec_alloc(const int dim);
 void vec_print(const int dim, const double *v);
 void vec_copy(const int dim, const double *v, double *vp);
 double *vec_alloc(const int dim);
 void vec_print(const int dim, const double *v);
 void vec_copy(const int dim, const double *v, double *vp);


@@ -6,3 +9,5 @@ void vec_inv(const int dim, double *v);
 void vec_add(const int dim, const double *b, double *a);  // a = a + b
 void vec_sub(const int dim, const double *b, double *a);  // a = a - b
 double vec_dotprod(const int dim, const double *a, const double *b);
 void vec_add(const int dim, const double *b, double *a);  // a = a + b
 void vec_sub(const int dim, const double *b, double *a);  // a = a - b
 double vec_dotprod(const int dim, const double *a, const double *b);

+
+#endif

diff --git a/src/de.c b/src/de.c
index 0e9f72c0c7900b173ecc2167525e540b74b65e3b..851a0f542abb442b131a9f2010aaf8b507c14567 100644 (file)
--- a/src/de.c
+++ b/src/de.c
@@ -1,15 +1,16 @@
 #include <stdlib.h>
 #include "vector.h"
 #include <stdlib.h>
 #include "vector.h"

-#include "de.h"
+#include "rand.h"
+#include "cgo.h"

 
 

-void de_optimize(de_parameters *par, double *res) {
+void cgo_de(cgo_de_parameters *par, double *res) {

     int l = par->particlec * par->dim;
     double *mem = malloc(sizeof(double) * (l + par->dim));
     int conv = 0;
     double *xs = mem;
     double *y = mem + l;
     for (double *x = xs; x < y; x += par->dim)
     int l = par->particlec * par->dim;
     double *mem = malloc(sizeof(double) * (l + par->dim));
     int conv = 0;
     double *xs = mem;
     double *y = mem + l;
     for (double *x = xs; x < y; x += par->dim)

-        vec_pick(par->dim, par->rrange, x);
+        vec_pick(par->dim, par->sample_range_min, par->sample_range_max, x);

     while (conv < 1000) {
         for (double *x = xs; x < y; x += par->dim) {
             double *picks[4] = { x };  // agents { x, a, b, c }
     while (conv < 1000) {
         for (double *x = xs; x < y; x += par->dim) {
             double *picks[4] = { x };  // agents { x, a, b, c }

diff --git a/src/main.c b/src/main.c
index fa4c9ef800c266c9a089a75d9d232a0440473194..8187ab0411b6d7c4b7b85434ccd1409b560309f5 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -1,7 +1,7 @@
 #include <math.h>
 #include "argph.h"
 #include "vector.h"
 #include <math.h>
 #include "argph.h"
 #include "vector.h"

-#include "de.h"
+#include "cgo.h"

 
 double b0(double *x) {
   return -x[0];
 
 double b0(double *x) {
   return -x[0];


@@ -28,10 +28,11 @@ int main(int argc, char *argv[]) {
     args.algorithm = de;
     args.outfile = "out.log";
     argp_parse(&argp, argc, argv, 0, 0, &args);
     args.algorithm = de;
     args.outfile = "out.log";
     argp_parse(&argp, argc, argv, 0, 0, &args);

-    range sample[2] = { (range) { -100.0, 100.0 }, { -100.0, 100.0 } };
-    de_parameters par = {2, 1000, sample, f};
+    double sample_min[2] = { -100.0, -100.0 };
+    double sample_max[2] = { 100.0, 100.0 };
+    cgo_de_parameters par = {2, 1000, sample_min, sample_max, f};

     double *res = vec_alloc(2);
     double *res = vec_alloc(2);

-    de_optimize(&par, res);
+    cgo_de(&par, res);

     printf("Converged at x=");
     vec_print(2, res);
     printf(" with fitness f(x)=%f\n", f(res));
     printf("Converged at x=");
     vec_print(2, res);
     printf(" with fitness f(x)=%f\n", f(res));

diff --git a/src/pso.c b/src/pso.c
index e7efa801d0a8f5a86232840fcd0d5a29eb86970a..12a7948ea3f299d9086a107f03c8272bc7cbc87a 100644 (file)
--- a/src/pso.c
+++ b/src/pso.c
@@ -1,10 +1,29 @@
 #include <math.h>
 #include <omp.h>
 #include <stdlib.h>
 #include <math.h>
 #include <omp.h>
 #include <stdlib.h>

-#include "pso.h"

 #include "vector.h"
 #include "vector.h"

+#include "rand.h"
+#include "cgo.h"

 
 

-void swarm_alloc(pso_parameters *par, swarm *sw) {
+typedef struct particle particle;
+
+typedef struct {
+  double *x;
+  double fitness;
+} particle_state;
+
+typedef struct {
+  particle *particles;
+  particle *global_best;
+} swarm;
+
+struct particle {
+  particle_state current;
+  particle_state best;
+  double *velocity;
+};
+
+void swarm_alloc(cgo_pso_parameters *par, swarm *sw) {

   sw->particles = malloc(sizeof(particle) * par->particlec);
   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
   sw->particles = malloc(sizeof(particle) * par->particlec);
   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {


@@ -14,7 +33,7 @@ void swarm_alloc(pso_parameters *par, swarm *sw) {
   }
 }
 
   }
 }
 

-void swarm_free(pso_parameters *par, swarm *sw) {
+void swarm_free(cgo_pso_parameters *par, swarm *sw) {

   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
     free(sw->particles[p].current.x);
   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
     free(sw->particles[p].current.x);


@@ -24,13 +43,13 @@ void swarm_free(pso_parameters *par, swarm *sw) {
   free(sw->particles);
 }
 
   free(sw->particles);
 }
 

-void swarm_populate(pso_parameters *par, swarm *sw, const range *rrange) {
+void swarm_populate(cgo_pso_parameters *par, swarm *sw, const double *min, const double *max) {

   sw->global_best = &sw->particles[0];
   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
     particle *pt = &sw->particles[p];
     for (int d = 0; d < par->dim; d++) {
   sw->global_best = &sw->particles[0];
   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
     particle *pt = &sw->particles[p];
     for (int d = 0; d < par->dim; d++) {

-      vec_pick(par->dim, rrange, pt->current.x);
+      vec_pick(par->dim, min, max, pt->current.x);

       vec_copy(par->dim, pt->current.x, pt->best.x);
     }
     pt->current.fitness = par->f(pt->current.x);
       vec_copy(par->dim, pt->current.x, pt->best.x);
     }
     pt->current.fitness = par->f(pt->current.x);


@@ -43,7 +62,7 @@ void swarm_populate(pso_parameters *par, swarm *sw, const range *rrange) {
   }
 }
 
   }
 }
 

-void swarm_velocity_update(pso_parameters *par, swarm *sw) {
+void swarm_velocity_update(cgo_pso_parameters *par, swarm *sw) {

   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
     particle *pt = &sw->particles[p];
   #pragma omp parallel for
   for (int p = 0; p < par->particlec; p++) {
     particle *pt = &sw->particles[p];


@@ -67,10 +86,10 @@ void swarm_velocity_update(pso_parameters *par, swarm *sw) {
   }
 }
 
   }
 }
 

-void pso_optimize(pso_parameters *par, particle_state *res) {
+void cgo_pso(cgo_pso_parameters *par, double *res) {

   swarm sw;
   swarm_alloc(par, &sw);
   swarm sw;
   swarm_alloc(par, &sw);

-  swarm_populate(par, &sw, par->rrange);
+  swarm_populate(par, &sw, par->sample_range_min, par->sample_range_max);

   int conv = 0;
   double best = INFINITY;
   while (conv < 1000) {
   int conv = 0;
   double best = INFINITY;
   while (conv < 1000) {


@@ -82,7 +101,6 @@ void pso_optimize(pso_parameters *par, particle_state *res) {
       conv = 0;
     }
   }
       conv = 0;
     }
   }

-  vec_copy(par->dim, sw.global_best->best.x, res->x);
-  res->fitness = sw.global_best->best.fitness;
+  vec_copy(par->dim, sw.global_best->best.x, res);

   swarm_free(par, &sw);
 }
   swarm_free(par, &sw);
 }

diff --git a/src/rand.c b/src/rand.c
index 323834e4937d9d9d8440a58d32b2dec459d40d92..5163c82ff957319fa0cfd2635517dd0cd517d41f 100644 (file)
--- a/src/rand.c
+++ b/src/rand.c
@@ -9,6 +9,6 @@ double randrange(double min, double max) {
   return rands() * (max - min) + min;
 }
 
   return rands() * (max - min) + min;
 }
 

-void vec_pick(const int dim, const range *rrange, double *v) {
-  for (int d = 0; d < dim; d++) v[d] = randrange(rrange[d].min, rrange[d].max);
+void vec_pick(const int dim, const double *min, const double *max, double *v) {
+  for (int d = 0; d < dim; d++) v[d] = randrange(min[d], max[d]);

 }
 }