ulvis.paste.net

Paste Search Dynamic
Recent pastes
printSample
  1.  
  2. //----------
  3. //  Курсовая
  4. //----------
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <math.h>
  9. //#include <omp.h>
  10.  
  11. #define CRYSTAL_X 3
  12. #define CRYSTAL_Y 3
  13. #define CRYSTAL_Z 3
  14.  
  15. #define B_ENERGY 0.0
  16. #define B1_ENERGY 1.0
  17. #define B2_ENERGY 1.0
  18. #define C_ENERGY 0.0
  19. #define D_ENERGY 0.0
  20.  
  21. #define PP_SIZE 3
  22. #define F_DE 1.0
  23. #define EPS 1
  24.  
  25. /*
  26.  *
  27.  */
  28.  
  29. typedef struct Domain Domain;
  30.  
  31. struct Domain {
  32.     double Sx;
  33.     double Sy;
  34.     double Sz;
  35. };
  36.  
  37. typedef struct Sample Sample;
  38.  
  39. struct Sample {
  40.     Domain(*crystal)[CRYSTAL_Y][CRYSTAL_Z];
  41. };
  42.  
  43. void normalize(Domain* domain) {
  44.  
  45.     double Sx = domain->Sx;
  46.     double Sy = domain->Sy;
  47.     double Sz = domain->Sz;
  48.  
  49.     double r = sqrt(Sx * Sx + Sy * Sy + Sz * Sz);
  50.  
  51.     domain->Sx = Sx / r;
  52.     domain->Sy = Sy / r;
  53.     domain->Sz = Sz / r;
  54.  
  55. }
  56.  
  57. double calculateEnergy(Sample sample) {
  58.  
  59.     double energy = 0;
  60.  
  61.     for (int x = 0; x < CRYSTAL_X; ++x) {
  62.         for (int y = 0; y < CRYSTAL_Y; ++y) {
  63.             for (int z = 0; z < CRYSTAL_Z; ++z) {
  64.  
  65.                 //  energy += B_ENERGY *;
  66.             }
  67.         }
  68.     }
  69.  
  70.     return energy;
  71. }
  72.  
  73. //  direction x == 0, y == 1, z == 2;
  74. //  Must be Sx type == Sy type == Sz type
  75. double doCrossingover (   int direction, Sample population[], int agent \
  76.                         , int v1, int v2, int v3    \
  77.                         , int x, int y, int z) {
  78.  
  79.     int crossingover = rand() % 2;
  80.  
  81.     //  v = v1 + F*(v2-v3);
  82.     if (crossingover) {
  83.         return \
  84.             (*(&population[v1].crystal[x][y][z].Sx + direction) + F_DE *\
  85.             (*(&population[v2].crystal[x][y][z].Sx + direction) -       \
  86.              *(&population[v3].crystal[x][y][z].Sx + direction)));
  87.     } else {
  88.         return *(&population[agent].crystal[x][y][z].Sx + direction);
  89.     };
  90. }
  91.  
  92. void createChild (Sample population[], int agent, Sample child) {
  93.  
  94.     int v1, v2, v3;
  95.  
  96.     v1 = rand() % (PP_SIZE - 1);
  97.     v2 = rand() % (PP_SIZE - 1);
  98.     v3 = rand() % (PP_SIZE - 1);
  99.  
  100.     if (v1 >= agent) ++v1;
  101.     if (v2 >= agent) ++v2;
  102.     if (v3 >= agent) ++v3;
  103.  
  104.     for (int x = 0; x < CRYSTAL_X; ++x) {
  105.         for (int y = 0; y < CRYSTAL_Y; ++y) {
  106.             for (int z = 0; z < CRYSTAL_Z; ++z) {
  107.  
  108.                 child.crystal[x][y][z].Sx = \
  109.                         doCrossingover(0, population, agent \
  110.                                         , v1, v2, v3    \
  111.                                         , x, y, z);
  112.  
  113.                 child.crystal[x][y][z].Sy = \
  114.                         doCrossingover(1, population, agent \
  115.                                         , v1, v2, v3    \
  116.                                         , x, y, z);
  117.  
  118.                 child.crystal[x][y][z].Sz = \
  119.                         doCrossingover(2, population, agent \
  120.                                         , v1, v2, v3    \
  121.                                         , x, y, z);
  122.  
  123.  
  124.                 normalize(&child.crystal[x][y][z]);
  125.  
  126.             }
  127.         }
  128.     }
  129. }
  130.  
  131. int evolvePopulation(Sample population[]) {
  132.  
  133.     Sample child;
  134.     child.crystal = malloc(sizeof (Domain[CRYSTAL_X][CRYSTAL_Y][CRYSTAL_Z]));
  135.  
  136.     int bestNum = -1;
  137.     double minimalEnergy, tmpEnergy;
  138.     minimalEnergy = ((double) 1.79769313486231570815e+308L);
  139.  
  140.     do {
  141.  
  142.         tmpEnergy = minimalEnergy;
  143.  
  144.         for (int agent = 0; agent < PP_SIZE; ++agent) {
  145.  
  146.             double childEnergy = 0, parentEnergy = 0;
  147.  
  148.             createChild(population, agent, child);
  149.  
  150.             childEnergy = calculateEnergy(child);
  151.             parentEnergy = calculateEnergy(population[agent]);
  152.  
  153.             if (childEnergy < parentEnergy) {
  154.  
  155.                 free(population[agent].crystal);
  156.                 population[agent].crystal = child.crystal;
  157.                 child.crystal = null;
  158.  
  159.                 if (childEnergy < minimalEnergy) {
  160.  
  161.                     minimalEnergy = childEnergy;
  162.                     bestNum = agent;
  163.                 }
  164.             } else if (parentEnergy < minimalEnergy) {
  165.  
  166.                 minimalEnergy = parentEnergy;
  167.                 bestNum = agent;
  168.             }
  169.         }
  170.     } while (tmpEnergy - minimalEnergy > EPS);
  171.  
  172.     free(child.crystal);
  173.  
  174.     return bestNum;
  175. }
  176.  
  177. void printSample(Sample sample){
  178.  
  179.     for (int x = 0; x < CRYSTAL_X; ++x) {
  180.         for (int y = 0; y < CRYSTAL_Y; ++y) {
  181.             for (int z = 0; z < CRYSTAL_Z; ++z) {
  182.  
  183.                 printf("%lf %lf %lf\t"  \
  184.                         , sample.crystal[x][y][z].Sx \
  185.                         , sample.crystal[x][y][z].Sy \
  186.                         , sample.crystal[x][y][z].Sz);
  187.             }
  188.             printf("\n");
  189.         }
  190.         printf("\n\n");
  191.     }
  192. }
  193.  
  194. int main(int argc, char** argv) {
  195.  
  196.     Sample population[PP_SIZE];
  197.  
  198.     //  population init
  199.     for (int agent = 0; agent < PP_SIZE; ++agent) {
  200.  
  201.         population[agent].crystal = \
  202.                 malloc(sizeof (Domain[CRYSTAL_X][CRYSTAL_Y][CRYSTAL_Z]));
  203.  
  204.         for (int x = 0; x < CRYSTAL_X; ++x)
  205.             for (int y = 0; y < CRYSTAL_Y; ++y)
  206.                 for (int z = 0; z < CRYSTAL_Z; ++z) {
  207.  
  208.                     double Sx = (double) rand() / RAND_MAX;
  209.                     double Sy = (double) rand() / RAND_MAX;
  210.                     double Sz = (double) rand() / RAND_MAX;
  211.  
  212.                     population[agent].crystal[x][y][z].Sx = Sx;
  213.                     population[agent].crystal[x][y][z].Sy = Sy;
  214.                     population[agent].crystal[x][y][z].Sz = Sz;
  215.  
  216.                     normalize(&population[agent].crystal[x][y][z]);
  217.  
  218.                 }
  219.     }
  220.  
  221.     int best = -2;
  222.  
  223.     best = evolvePopulation(population);
  224.  
  225.     printSample(population[best]);
  226.  
  227.     for (int agent = 0; agent < PP_SIZE; ++agent) {
  228.         free(population[agent].crystal);
  229.     }
  230.  
  231.     return 0;
  232. }
Parsed in 0.036 seconds