# 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.038 seconds