fitness.c

比较完整的遗传算法的源代码

#include <math.h>

#include "petrol.h"
#include "utils.h"

static double DecodeBinary(int *a, int l);
static double F1(Individual *i);
static double F2(Individual *i);
static double F3(Individual *i);
static double F4(Individual *i);
static double F5(Individual *i);
static double OneMax(Individual *i);

double Fitness(Individual *i) {
  sleep(2);
  return OneMax(i);
}

double F1(Individual *i) {
  double x1, x2, x3;

  if (i->chromLen < 30)
    return -1;

  x1 = DecodeBinary(i->chrom, 10);
  x2 = DecodeBinary(i->chrom + 10, 10);
  x3 = DecodeBinary(i->chrom + 20, 10);

  x1 = -5.12 + (10.23 / 1023.0) * x1;
  x2 = -5.12 + (10.23 / 1023.0) * x2;
  x3 = -5.12 + (10.23 / 1023.0) * x3;

  return 80 - (x1 * x1 + x2 * x2 + x3 * x3);
}

double F2(Individual *i) {
  double x1, x2;

  if (i->chromLen < 24)
    return -1;
  x1 = DecodeBinary(i->chrom, 12);
  x2 = DecodeBinary(i->chrom + 12, 12);

  x1 = -2.408 + (4.095 / 4095) * x1;
  x2 = -2.408 + (4.095 / 4095) * x2;

  return 8000 - (100 * pow(x1 * x1 - x2, 2) + pow(1 - x1, 2));
}

double F3(Individual *i) {
  double x[5], result;
  int n, m;

  if (i->chromLen < 50)
    return -1;

  for (n = 0, m = 0, result = 0.0; n < 5; n++, m += 10) {
    x[n] = DecodeBinary(i->chrom + m, 10);
    x[n] = -5.12 + (10.23 / 1023) * x[n];
    result += floor(x[n]);
  }
  
  return 31 - result;
}

double F4(Individual *i) {
  double x[30], result;
  int n, m;

  if (i->chromLen < 240)
    return -1;

  for (n = 0, m = 0, result = 0.0; n < 30; n++, m += 8) {
    x[n] = DecodeBinary(i->chrom + m, 8);
    x[n] = -1.28 + (2.55 / 255) * x[n];
    result += ((n + 1) * pow(x[n], 4)) + ((flip(0.5) ? 1 : -1) * (randFraction()));
  }

  return 1000 - result;
}

double F5(Individual *m) {
  static int a[2][25] ={
    {-32, -16, 0, 16, 32, -32, -16, 0, 16, 32, -32, -16, 0,
     16, 32, -32, -16, 0, 16, 32, -32, -16, 0, 16, 32 },
    {-32, -32, -32, -32, -32, -16, -16, -16, -16,
     -16, 16, 16, 16, 16, 16, 32, 32, 32, 32, 32  }};

  double x[5], result, temp;
  int i, j;

  if (m->chromLen < 85)
    return -1;

  for (i = 0, j = 0; i < 5; i++, j += 17) {
    x[i] = DecodeBinary(m->chrom + j, 17);
    x[i] = -65.536 + (131.071 / 131071) * x[i];
  }

  for (j = 0, result = 0.0; j < 25; j++) {
    for (i = 0, temp = 0.0; i < 2; i++) {
      temp += pow(x[i] - a[i][j], 6);
    }
    result += 1 / (j + temp);
  }

  return 5000 - result;
}

double OneMax(Individual *i) {
  int n;
  double x;

  for (n = 0, x = 0.0; n < i->chromLen; n++) {
    if (i->chrom[n] == 1) {
      x += 1.0;
    }
  }
  
  return x;
  
}

double DecodeBinary(int *a, int l) {
  int i;
  double result;

  for (i = 0, result = 0.0; i < l; i++) {
    result += (a[i] == 0 ? 0.0 : pow(2.0, (double)i));
  }

  return result;
}