Форум программистов, компьютерный форум CyberForum.ru

Моделирование систем - C++

Восстановить пароль Регистрация
 
Morfeus
9 / 9 / 1
Регистрация: 22.10.2010
Сообщений: 110
13.12.2012, 12:05     Моделирование систем #1
Кто-нибудь встречал или делал такое задание?
А то я половины понять не могу
Пробный код есть, но так как задание разобрать не могу ))) не могу и с кодом нормально разобраться
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
13.12.2012, 12:05     Моделирование систем
Посмотрите здесь:

Моделирование C++
Перевод систем счислений C++
Перевод систем счисления. C++
C++ Нейрокомпьютерное моделирование
C++ перевод систем счисления
C++ мат.моделирование
C++ Решение систем уравнений
C++ Моделирование COM

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Morfeus
9 / 9 / 1
Регистрация: 22.10.2010
Сообщений: 110
13.12.2012, 12:05  [ТС]     Моделирование систем #2
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
#include <stdio.h>
#include <cstdlib>
#include <cmath>
#include <windows.h>
 
int time_cur = 0; //curent model time
int GT = 0; // next generation order time
int g_av; // average of order generation time
int g_di; // deviation of order generation time
int q_ph; // quantity of phases
int N = 0; // quantity of output orders
int Nl = 0; // quantity of lost orders
int stop; // stop condition (0 - time, 1 - order)
int q_st; // quantity of stop condition items
 
struct dev // device
{
    int aver; // average of service time
    int diff; // deviation of service time
    int Z; // state variable
// for statistica
    int T; // service start time
    int N; // quantity of serviced order
    double S; // sum of service time
    double S2; // sum of square of service time
} **a_dev;
struct node_que // node of list odrers in queue
{
    int T; // seize queue time
    struct node_que *next, *prev;
};
struct que // queue
{
    int cap; // capacity (limit)
    int Z; // curent length queue
    int q_d; // quantity of devices in phase
// for statistica
    struct node_que *head, *tail;
    int N; // quantity of released order
    int LT; // queue length change time
    double ST; // sum of queue time
    double ST2; // sum of square of queue time
    double SL; // sum of queue length
    double SL2; // sum of square of queue length
} *a_que;
struct node // node of future evevt list
{
    int time;
    int phase;
    int device;
    struct node *next, *prev;
} *l_head=NULL, *l_tail=NULL;
//================================================================================
int time_event(int a, int b);
void rm_node_que(int phas);
void seiz_dev(int phas, int dev);
void seiz_que(int phas);
void trans_order_prev(int phas, int dev);
#define serv_order(phas, dev) ad_node_even(phas, dev, time_event(a_dev[phas][dev].aver, a_dev[phas][dev].diff))
 
void ad_node_even(int phas, int dev, int time)
{
    struct node *point=l_tail, *pt;
    // create
    pt = (struct node *)malloc(sizeof(struct node));
    pt->phase = phas;
    pt->device = dev;
    pt->time = time;
    // insert
    if (point==NULL)
    {
        pt->next = pt->prev = NULL;
        l_head = l_tail = pt;
    }
    else
    {
        while (pt->time < point->time)
        {
            if ((point=point->prev) == NULL)
            break;//}
        }
        pt->prev = point; // link to prev (always safely)
        if ((point != NULL) && (point->next != NULL)) // insert as intermediate node of list
        {
            pt->next = point->next; // link to next
            point->next->prev = pt; // link from next
            point->next = pt; // link from prev
        }
        else
        {
            if (point == NULL) // insert to head of list
            {
                pt->next = l_head; // link to next
                l_head->prev = pt; // link from next
                l_head = pt;
            }
            else // insert to tail of list
            {
                pt->next = NULL; // link to next
                l_tail->next = pt; // link from prev
                l_tail = pt;
            }
        }
    }
}
void ad_node_que(int phas)
{
    struct node_que *point=a_que[phas].tail,*pt;
    pt = (struct node_que *)malloc(sizeof(struct node_que));
    pt->T=time_cur;
    if (point==NULL)
    {
        pt->next = pt->prev = NULL;
        a_que[phas].head = a_que[phas].tail = pt;
    }
    else
    {
        pt->prev = point; // link to prev
        point->next = pt; // link from prev
        pt->next = NULL;
        a_que[phas].tail = pt;
    }
}
void gen_order()
{
    int i;
    time_cur = GT; // renew curent time
    GT = time_event(g_av, g_di); // planing next order generation
    for (i=0; i < a_que[0].q_d; i++)
    if (a_dev[0][i].Z == 0)
    {
        seiz_dev(0, i); // seize device
        i = 2*a_que[0].q_d; // not need queue
        break;
    }
    if (i == a_que[0].q_d) // need queue
    {
        if (a_que[0].Z < a_que[0].cap)
        seiz_que(0); // seize queue
        else
        Nl++; // lost order
    }
}
int input_model()
{
    int cur, i=0, j=0;
    char c;
    printf("============\n    INPUT\n============\n");
    FILE *fp;
    fp=fopen("input.txt", "r");
    fscanf (fp, "%d", &stop); // stop model condition
    fscanf (fp, "%d", &q_st); // stop model condition items
    printf ("\nStop condition = %d ", q_st);
    if (stop == 0)
        printf("time");
    else
        printf("orders");
    fscanf (fp, "%d", &g_av); // generation average time
    fscanf (fp, "%d", &g_di); // generation deviation time
    printf ("\nOrders generation = %d+-%d", g_av, g_di);
    fscanf (fp, "%d", &q_ph); // quantity of phases
// create array of queues
    a_que=(struct que *)malloc(q_ph*sizeof(struct que));
    printf("\n--\nQueues capacity\n--");
// initiate array of queues
    do
    {
        fscanf (fp, "%d", &cur);
        a_que[i].cap=cur;
        a_que[i].Z=0;
        a_que[i].N=0;
        a_que[i].LT=0;
        a_que[i].ST=0;
        a_que[i].ST2=0;
        a_que[i].SL=0;
        a_que[i].SL2=0;
        a_que[i].head=NULL;
        a_que[i].tail=NULL;
        printf ("\nque[%d]  %d", i++, a_que[i].cap);
    }
    while (c=fgetc(fp) != '\n');
// create array of phases (array of pointers of devices)
    a_dev=(struct dev **)malloc((i)*sizeof(struct dev *));
    i=0;
    printf("\n---\ndevices service time");
    while (1)
    {
        fscanf (fp, "%d", &cur);
// create array of devices
        a_dev[i]=(struct dev *)malloc(cur*sizeof(struct dev));
// remember quantity of devices in phase
        a_que[i].q_d=cur;
// initiate array of devices
        printf("\n--");
        do
        {
            fscanf (fp, "%d", &cur);
            a_dev[i][j].aver=cur;
            printf ("\ndev[%d][%d]  %-3d", i, j, a_dev[i][j].aver);
            fscanf (fp, "%d", &cur);
            a_dev[i][j].diff=cur;
            printf ("+-%-3d",a_dev[i][j].diff);
            a_dev[i][j].S=0;
            a_dev[i][j].S2=0;
            a_dev[i][j].N=0;
            a_dev[i][j++].Z=0;
            if ((c=fgetc(fp)) == EOF)
            {
                fclose (fp);
                return 0;
            }
        }
        while (c != '\n');
        i++;
        j=0;
    }
}
void print_list_que(int phas)
{
    struct node_que *pt=a_que[phas].head;
    while (pt!=NULL)
    {
    printf("%d | ", pt->T);
    pt=pt->next;
    }
}
int ps_rand(int a)
{
    static int x=1, y=1, z=1, s=1;
    x=(2*x)%16381;
    y=(2*y)%16363;
    z=(2*z)%16349;
    return ((s=s+x+y+z)%16383)%a;
}
void rel_dev(int phas, int dev)
{
    a_dev[phas][dev].Z = 0;
// for statistica
    int a = (time_cur-a_dev[phas][dev].T);
    a_dev[phas][dev].S += a;
    a_dev[phas][dev].S2 += a*a;
    a_dev[phas][dev].N++;
}
void rel_que(int phas)
{
// for statistica
    // for length
    int a = (time_cur-a_que[phas].LT);
    int b = a_que[phas].Z;
    a_que[phas].SL += a*b;
    a_que[phas].SL2 += a*b*b;
    a_que[phas].LT = time_cur;
    // for time
    b = time_cur-a_que[phas].head->T;
    a_que[phas].ST += b;
    a_que[phas].ST2 += b*b;
    a_que[phas].N++;
    rm_node_que(phas);
// for modelling
    a_que[phas].Z--;
}
 
void rm_node_even()
{
    struct node *pt;
    if (l_head != NULL) // always truth in this system, but for multipurpose
    {
        pt=l_head->next;
        if (pt != NULL) pt->prev=NULL;
        free(l_head);
        if ((l_head=pt)==NULL) l_tail=NULL;
    }
}
void rm_node_que(int phas)
{
    struct node_que *pt;
    if (a_que[phas].head != NULL) // always truth in this system, but for multipurpose
    {
        pt=a_que[phas].head->next;
        if (pt != NULL) pt->prev=NULL;
        free(a_que[phas].head);
        if ((a_que[phas].head=pt)==NULL) a_que[phas].tail=NULL;
    }
}
void seiz_dev(int phas, int dev)
{
    serv_order(phas, dev);
    a_dev[phas][dev].Z = 1;
    a_dev[phas][dev].T = time_cur;
}
void seiz_que(int phas)
{
// for statistica
    // for length
    int a = (time_cur-a_que[phas].LT);
    int b = a_que[phas].Z;
    a_que[phas].SL += a*b;
    a_que[phas].SL2 += a*b*b;
    a_que[phas].LT = time_cur;
    ad_node_que(phas);
// for modelling
    a_que[phas].Z++;
}
int stop_model()
{
    if (stop == 0)
    return ((time_cur < q_st) ? 0: 1);
    else
    return ((N < q_st) ? 0: 1);
}
int time_event(int a, int b)
{
    if (b != 0)
    return time_cur+a-b+ps_rand(2*b);
    else
    return time_cur+a;
}
void trans_order_next(int phas, int dev)
{
// transfer order to next phase
    int i;
    time_cur = l_head->time; // renew curent time
    if (phas == q_ph-1)
    {
        rel_dev(phas, dev); // release device
        N++; // out from system
    }
    else
    {
        for (i=0; i < a_que[phas+1].q_d; i++)
        if (a_dev[phas+1][i].Z == 0)
        {
            seiz_dev(phas+1, i); // seize next device
            rel_dev(phas, dev); // release device;
            i = 2*a_que[phas+1].q_d; // not need queue
            break;
        }
        if (i == a_que[phas+1].q_d) // need queue
        {
            if (a_que[phas+1].Z < a_que[phas+1].cap)
            {
                seiz_que(phas+1); // seize next queue
                rel_dev(phas, dev); // release device;
            }
            else
            a_dev[phas][dev].Z = 2; // blocking device
        }
    }
    if (a_dev[phas][dev].Z == 0)
// transfer order from queue or previous phase
    trans_order_prev(phas, dev);
    rm_node_even();
}
void trans_order_prev(int phas, int dev)
{
    int i;
// transfer order from queue
    if (a_que[phas].Z > 0)
        {
            rel_que(phas); // release queue
            seiz_dev(phas, dev); // seize device
        }
// transfer order from previous phase (unblocking previuos device)
    if (phas != 0)
    for (i=0; i < a_que[phas-1].q_d; i++)
        if (a_dev[phas-1][i].Z == 2)
        {
            if (a_que[phas].Z == a_que[phas].cap-1)
                seiz_que(phas); // seize queue
            else seiz_dev(phas, dev); // seize device
            rel_dev(phas-1, i); // unblocking previuos device
            trans_order_prev(phas-1, i); // recursive call for previous
            break;
        }
}
//============================================================================
int main()
{
    if(input_model() == -1) return 0;
    printf("\n\n============\n    START\n============\n\nCT - curent time\nGT - generation time planing\nST - service time planing\n---\n");
 
    while(stop_model() != 1)
    {
        if((l_head == NULL) || (GT < l_head->time)) gen_order();
        else trans_order_next(l_head->phase, l_head->device);
        //----------------------------------------------------------------------------------------------
        int i;
        printf("\nCT = %-6d GT = %-6d ST = %-6d lost = %-6d serv = %-6d\n", time_cur, GT, l_head->time, Nl, N);
        printf("list_even = ");
        //----------------------------------------------------------------------------------------------
        struct node *pt=l_head;
        while (pt!=NULL)
        {
        printf("%d %d %d | ", pt->phase, pt->device, pt->time);
        pt=pt->next;
        }
        //----------------------------------------------------------------------------------------------
        printf("\n-------");
        for (i=0; i<q_ph; i++)
        {
            if (a_que[i].head != NULL)
            {
                printf("\nque[%2d] = ", i );
                print_list_que(i);
            }
        }
        printf("\n----------------------------------------------------------");
    }
    //--------------------------------------------------------------------------------------------------
    int i, j;
    double E, V;
    printf("\n\n============\n   RESULT\n============\n");
    printf("\nQT  - Queue time\nQL  - Queue length");
    printf("\nStL - Queue length at stop moment\nStQ - List of orders in queue at stop moment");
    printf("\nST  - Service time\nSO  - Serviced orders\nStB - Busy at stop moment (yes or \" \")\nDU  - Device use coefficient");
    printf("\n--\nQueue QT QL StL === StQ\nDevice ST SO StB DU");
    printf("\na+-b (Expectation +- sqrt(Variance)\n");
    for (i=0; i<q_ph; i++)
    {
        printf("----\nque [%-2d]", i);
        if (a_que[i].N == 0)
            printf("%27s", " ");
        else
        {
            E=a_que[i].ST; // queue time expectation
            if (a_que[i].N > 1)
                V=(a_que[i].ST2-E*E/a_que[i].N)/(a_que[i].N-1); // queue time variance
            else V=0;
            printf("%6.1f +- %-4.1f", E/a_que[i].N, sqrt(V));
            E=a_que[i].SL; // queue length expectation
        V=(a_que[i].SL2-E*E/time_cur)/(time_cur-1); // queue length variance
        printf("%6.1f +- %-3.1f", E/time_cur, sqrt(V));
        }
        printf("%6d === ", a_que[i].Z);
        print_list_que(i);
        printf("\n--\n");
        for (j=0; j<a_que[i].q_d; j++)
        {
            if (a_dev[i][j].N == 0)
                printf("dev [%-2d %-2d]%21s", i, j, " ");
            else
            {
                E=a_dev[i][j].S; // service time expectation
                if (a_dev[i][j].N > 1)
                    V=(a_dev[i][j].S2-E*E/a_dev[i][j].N)/(a_dev[i][j].N-1); // service time variance
                else V=0;
                printf("dev [%-2d %-2d] %6.1f +- %-3.1f %6d", i, j, E/a_dev[i][j].N, sqrt(V), a_dev[i][j].N);
            }
            if (a_dev[i][j].Z != 0)
                printf("   yes");
            else
                printf("      ");
            printf("   %-4.2f", a_dev[i][j].S/time_cur);
            printf("\n");
        }
    }
    printf("\nTOTAL\n----\nTIME = %d  SERVICED = %d  LOST = %d\n", time_cur, N, Nl);
    //--------------------------------------------------------------------------------------------------
    system("pause");
}
Yandex
Объявления
13.12.2012, 12:05     Моделирование систем
Ответ Создать тему
Опции темы

Текущее время: 08:59. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru