1: #include <stdio.h>
2: #include <stdlib.h>
3: #include <string.h>
4:
5: #include "random.c"
6:
7: #include <zebra.h>
8:
9: #include "thread.h"
10: #include "vty.h"
11: #include "log.h"
12: #include "linklist.h"
13:
14: #include "spgrid.h"
15:
16:
17: #define DASH '-'
18: #define VERY_FAR 100000000
19:
20: #define DOUBLE_CYCLE 0
21: #define CYCLE 1
22: #define PATH 2
23:
24: #define NO 0
25: #define YES 1
26:
27: #define NODE( x, y ) (x*Y + y + 1)
28:
29: /*
30: * Prototypes.
31: */
32: void free_arc(void *);
33: void help(struct vty *);
34: void print_arc(struct vty *, struct list *, long, long, long);
35: void hhelp(struct vty *);
36: void usage(struct vty *);
37:
38: const char *graph_type[] = {
39: "double cycle",
40: "cycle",
41: "path"
42: };
43:
44: struct arc *arc;
45:
46: char args[30];
47:
48: long X, /* horizontal size of grid */
49: Y; /* vertical size of grid */
50:
51: long x,
52: y,
53: y1, y2, yp,
54: dl, dx, xn, yn, count,
55: *mess;
56:
57: double n;
58: long n0,
59: source,
60: i,
61: i0,
62: j,
63: dij;
64:
65: double m;
66: long m0,
67: mc,
68: k;
69:
70: long *p,
71: p_t,
72: l,
73: lx;
74:
75: long seed,
76: seed1,
77: seed2;
78:
79: int ext=0;
80:
81: /* initialized by default values */
82:
83: /* variables for generating one layer */
84:
85: /* variables for generating spanning graph */
86: int c_f = 0, cw_f = 0, cm_f = 0, cl_f = 0;
87:
88: int cw = DOUBLE_CYCLE; /* type of spanning graph */
89: long cm = 0, /* lower bound of the interval */
90: cl = 100; /* upper bound of the interval */
91:
92: /* variables for generating additional arcs */
93: int a_f = 0, ax_f = 0, am_f = 0, al_f = 0;
94:
95: long ax = 0, /* number of additional arcs */
96: am = 0, /* lower bound of the interval */
97: al = 100; /* upper bound of the interval */
98:
99: /* variables for inter-layer arcs */
100: int i_f = 0, ip_f = 0, ix_f = 0, ih_f = 0,
101: im_f = 0, il_f = 0, in_f = 0, is_f = 0;
102:
103: int ip = NO; /* to mess or not to mess */
104: long ix = 1, /* number of interlayered arcs in a NODE */
105: ih = 1, /* step between two layeres */
106: il = 10000, /* upper bound of the interval */
107: im = 1000; /* lower bound of the interval */
108: double in = 1, /* l *= in * |x1-x2| */
109: is = 0; /* l *= is * |x1-x2|^2 */
110:
111: /* variables for artifical source */
112: int s_f = 0, sl_f = 0, sm_f = 0;
113: long sl = VERY_FAR, /* upper bound of artifical arc */
114: sm, /* lower bound of artifical arc */
115: s;
116:
117: /* variables for potentials */
118: int p_f = 0, pl_f = 0, pm_f = 0, pn_f = 0, ps_f = 0;
119:
120: long pl, /* upper bound of the interval */
121: pm; /* lower bound of the interval */
122: double pn = 0, /* p += ln * (x+1) */
123: ps = 0; /* p += ls * (x+1)^2 */
124:
125: int np; /* number of parameter parsing now */
126:
127:
128: void
129: free_arc (void *val) {
130: free(val);
131: }
132:
133: void
134: print_arc (struct vty *vty, struct list *topology, long i, long j, long length)
135: {
136: struct arc *myarc;
137:
138: l = length;
139: if ( p_f ) l += ( p[i] - p[j] );
140: // vty_out (vty,"a %8ld %8ld %12ld%s", i, j, l ,VTY_NEWLINE);
141: myarc = malloc (sizeof(struct arc));
142: myarc->from_node = i;
143: myarc->to_node = j;
144: myarc->distance = l;
145: topology->del = free_arc;
146: listnode_add (topology, myarc);
147: }
148:
149: /* ---- help ---- */
150: void
151: help (struct vty *vty) {
152: // if ( args[2] == 'h') hhelp (vty);
153: vty_out (vty,"grid network generator for shortest paths problem.%s",VTY_NEWLINE);
154: vty_out (vty,"Generates problems in extended DIMACS format.%s",VTY_NEWLINE);
155: vty_out (vty,"X Y seed [ -cl#i -cm#i -c{c|d|p} -ip -il#i -im#i -p -pl#i -pm#i... ]%s",VTY_NEWLINE);
156: vty_out (vty,"#i - integer number%s",VTY_NEWLINE);
157: vty_out (vty,"-cl#i - #i is the upper bound on layer arc lengths (default 100)%s",VTY_NEWLINE);
158: vty_out (vty,"-cm#i - #i is the lower bound on layer arc lengths (default 0)%s",VTY_NEWLINE);
159: vty_out (vty,"-c#t - #t is the type of connecting graph: { c | d | p }%s",VTY_NEWLINE);
160: vty_out (vty," c - cycle, d - double cycle, p - path (default d)%s",VTY_NEWLINE);
161: vty_out (vty,"-ip - shuffle inter-layer arcs (default NO)%s",VTY_NEWLINE);
162: vty_out (vty,"-il#i - #i is the upper bound on inter-layer arc lengths (default 10000)%s",VTY_NEWLINE);
163: vty_out (vty,"-im#i - #i is the lower bound on inter-layer arc lengths (default 1000)%s",VTY_NEWLINE);
164: vty_out (vty,"-p - generate potentials%s",VTY_NEWLINE);
165: vty_out (vty,"-pl#i - #i is the upper bound on potentials (default il)%s",VTY_NEWLINE);
166: vty_out (vty,"-pm#i - #i is the lower bound on potentials (default im)%s",VTY_NEWLINE);
167: vty_out (vty,"%s",VTY_NEWLINE);
168: vty_out (vty,"-hh - extended help%s",VTY_NEWLINE);
169: }
170:
171: /* --------- sophisticated help ------------ */
172: void
173: hhelp (struct vty *vty) {
174: /*
175: zlog_info (
176: "\n'%s' - grid network generator for shortest paths problem.\n\
177: Generates problems in extended DIMACS format.\n\
178: \n\
179: %s X Y seed [ -cl#i -cm#i -c{c|d|p}\n\
180: -ax#i -al#i -am#i\n\
181: -ip -il#i -im#i -in#i -is#i -ix#i -ih#i\n\
182: -p -pl#i -pm#i -pn#f -ps#f\n\
183: -s -sl#i -sm#i\n\
184: ]\n\
185: %s -hh file_name\n\
186: \n\
187: #i - integer number #f - real number\n\
188: \n\
189: Parameters of connecting arcs within one layer:\n\
190: -cl#i - #i is the upper bound on arc lengths (default 100)\n\
191: -cm#i - #i is the lower bound on arc lengths (default 0)\n\
192: -c#t - #t is the type of connecting graph: { c | d | p }\n\
193: c - cycle, d - double cycle, p - path (default d)\n\
194: \n\
195: Parameters of additional arcs within one layer:\n\
196: -ax#i - #i is the number of additional arcs (default 0)\n\
197: -al#i - #i is the upper bound on arc lengths (default 100)\n\
198: -am#i - #i is the lower bound on arc lengths (default 0)\n\
199: \n\
200: Interlayerd arc parameters:\n\
201: -ip - shuffle inter-layer arcs (default NO)\n\
202: -il#i - #i is the upper bound on arc lengths (default 10000)\n\
203: -im#i - #i is the lower bound on arc lengths (default 1000)\n\
204: -in#f - multiply l(i, j) by #f * x(j)-x(i) (default 1)\n\
205: if #f=0 - don't multiply\n\
206: -is#f - multiply l(i, j) by #f * (x(j)-x(i))^2 (default NO)\n\
207: -ix#i - #i - is the number of arcs from a node (default 1)\n\
208: -ih#i - #i - is the step between connected layers (default 1)\n\
209: \n\
210: Potential parameters:\n\
211: -p - generate potentials \n\
212: -pl#i - #i is the upper bound on potentials (default ll)\n\
213: -pm#i - #i is the lower bound on potentials (default lm)\n\
214: -pn#f - multiply p(i) by #f * x(i) (default NO)\n\
215: -ps#f - multiply p(i) by #f * x(i)^2 (default NO)\n\
216: \n");
217: zlog_info (
218: " Artificial source parameters:\n\
219: -s - generate artificial source with default connecting arc lengths\n\
220: -sl#i - #i is the upper bound on art. arc lengths (default 100000000)\n\
221: -sm#i - #i is the lower bound on art. arc lengths (default sl)\n\"
222: );*/
223: }
224:
225: /* ----- wrong usage ----- */
226: void
227: usage (struct vty *vty) {
228: vty_out (vty,"usage: X Y seed [-ll#i -lm#i -cl#i -p -pl#i -pm#i ...]%s",VTY_NEWLINE);
229: vty_out (vty,"help: -h or -hh%s",VTY_NEWLINE);
230:
231: if ( np > 0 )
232: zlog_err ("error in parameter # %d\n\n", np );
233: }
234:
235:
236: /* parsing parameters */
237: /* checks the validity of incoming parameters */
238: int
239: spgrid_check_params ( struct vty *vty, int argc, const char **argv)
240: {
241: /* initialized by default values */
242: ext=0;
243:
244: /* variables for generating one layer */
245:
246: /* variables for generating spanning graph */
247: c_f = 0;
248: cw_f = 0;
249: cm_f = 0;
250: cl_f = 0;
251:
252: cw = PATH; /* type of spanning graph */
253: cm = 0; /* lower bound of the interval */
254: cl = 63; /* upper bound of the interval */
255:
256: /* variables for generating additional arcs */
257: a_f = 0;
258: ax_f = 0;
259: am_f = 0;
260: al_f = 0;
261:
262: ax = 0; /* number of additional arcs */
263: am = 0; /* lower bound of the interval */
264: al = 63; /* upper bound of the interval */
265:
266: /* variables for inter-layer arcs */
267: i_f = 0;
268: ip_f = 0;
269: ix_f = 0;
270: ih_f = 0;
271: im_f = 0;
272: il_f = 0;
273: in_f = 0;
274: is_f = 0;
275:
276: ip = NO; /* to mess or not to mess */
277: ix = 1; /* number of interlayered arcs in a NODE */
278: ih = 1; /* step between two layeres */
279: il = 63; //was 10000; /* upper bound of the interval */
280: im = 0; //was 1000; /* lower bound of the interval */
281: in = 1; /* l *= in * |x1-x2| */
282: is = 0; /* l *= is * |x1-x2|^2 */
283:
284: /* variables for artifical source */
285: s_f = 0;
286: sl_f = 0;
287: sm_f = 0;
288: sl = VERY_FAR; /* upper bound of artifical arc */
289:
290: /* variables for potentials */
291: p_f = 0;
292: pl_f = 0;
293: pm_f = 0;
294: pn_f = 0;
295: ps_f = 0;
296:
297: pn = 0; /* p += ln * (x+1) */
298: ps = 0; /* p += ls * (x+1)^2 */
299:
300:
301: if ( argc < 1 ) {
302: usage (vty);
303: return 1;
304: }
305:
306: np = 0;
307:
308: strcpy ( args, argv[0] );
309:
310: if ((args[0] == DASH) && (args[1] == 'h'))
311: help (vty);
312:
313: if ( argc < 3 ) {
314: usage (vty);
315: return 1;
316: }
317:
318: /* first parameter - horizontal size */
319: np = 1;
320: if ( ( X = atoi ( argv[0] ) ) < 1 ) {
321: usage (vty);
322: return 1;
323: }
324:
325: /* second parameter - vertical size */
326: np = 2;
327: if ( ( Y = atoi ( argv[1] ) ) < 1 ) {
328: usage (vty);
329: return 1;
330: }
331:
332: /* third parameter - seed */
333: np=3;
334: if ( ( seed = atoi ( argv[2] ) ) <= 0 ) {
335: usage (vty);
336: return 1;
337: }
338:
339: /* other parameters */
340: for ( np = 3; np < argc; np ++ ) {
341: strcpy ( args, argv[np] );
342: if ( args[0] != DASH ) {
343: usage (vty);
344: return 1;
345: }
346:
347: switch ( args[1] ) {
348: case 'c' : /* spanning graph in one layer */
349: c_f = 1;
350: switch ( args[2] ) {
351: case 'l': /* upper bound of the interval */
352: cl_f = 1;
353: cl = atol ( &args[3] );
354: break;
355: case 'm': /* lower bound */
356: cm_f = 1;
357: cm = atol ( &args[3] );
358: break;
359: case 'c': /* type - cycle */
360: cw_f = 1;
361: cw = CYCLE;
362: break;
363: case 'd': /* type - double cycle */
364: cw_f = 1;
365: cw = DOUBLE_CYCLE;
366: break;
367: case 'p': /* type - path */
368: cw_f = 1;
369: cw = PATH;
370: break;
371:
372: default: /* unknown switch value */
373: usage (vty);
374: return 1;
375: }
376: break;
377:
378: case 'a' : /* additional arcs in one layer */
379: a_f = 1;
380: switch ( args[2] )
381: {
382: case 'l': /* upper bound of the interval */
383: al_f = 1;
384: al = atol ( &args[3] );
385: break;
386: case 'm': /* lower bound */
387: am_f = 1;
388: am = atol ( &args[3] );
389: break;
390: case 'x': /* number of additional arcs */
391: ax_f = 1;
392: ax = atol ( &args[3] );
393: if ( ax < 0 )
394: {
395: usage (vty);
396: return 1;
397: }
398: break;
399:
400: default: /* unknown switch value */
401: {
402: usage (vty);
403: return 1;
404: }
405: }
406: break;
407:
408:
409: case 'i' : /* interlayered arcs */
410: i_f = 1;
411:
412: switch ( args[2] )
413: {
414: case 'l': /* upper bound */
415: il_f = 1;
416: il = atol ( &args[3] );
417: break;
418: case 'm': /* lower bound */
419: im_f = 1;
420: im = atol ( &args[3] );
421: break;
422: case 'n': /* additional length: l *= in*|i1-i2| */
423: in_f = 1;
424: in = atof ( &args[3] );
425: break;
426: case 's': /* additional length: l *= is*|i1-i2|^2 */
427: is_f = 1;
428: is = atof ( &args[3] );
429: break;
430: case 'p': /* mess interlayered arcs */
431: ip_f = 1;
432: ip = YES;
433: break;
434: case 'x': /* number of interlayered arcs */
435: ix_f = 1;
436: ix = atof ( &args[3] );
437: if ( ix < 1 ) {
438: usage (vty);
439: return 1;
440: }
441: break;
442: case 'h': /* step between two layeres */
443: ih_f = 1;
444: ih = atof ( &args[3] );
445: if ( ih < 1 ) {
446: usage (vty);
447: return 1;
448: }
449: break;
450: default: /* unknown switch value */
451: usage (vty);
452: return 1;
453: }
454: break;
455:
456: case 's' : /* additional source */
457: s_f = 1;
458: if ( strlen ( args ) > 2 )
459: {
460: switch ( args[2] )
461: {
462: case 'l': /* upper bound of art. arc */
463: sl_f = 1;
464: sl = atol ( &args[3] );
465: break;
466: case 'm': /* lower bound of art. arc */
467: sm_f = 1;
468: sm = atol ( &args[3] );
469: break;
470: default: /* unknown switch value */
471: usage (vty);
472: return 1;
473: }
474: }
475: break;
476:
477: case 'p' : /* potentials */
478: p_f = 1;
479: if ( strlen ( args ) > 2 )
480: {
481: switch ( args[2] )
482: {
483: case 'l': /* upper bound */
484: pl_f = 1;
485: pl = atol ( &args[3] );
486: break;
487: case 'm': /* lower bound */
488: pm_f = 1;
489: pm = atol ( &args[3] );
490: break;
491: case 'n': /* additional: p *= pn*(x+1) */
492: pn_f = 1;
493: pn = atof ( &args[3] );
494: break;
495: case 's': /* additional: p = ps* (x+1)^2 */
496: ps_f = 1;
497: ps = atof ( &args[3] );
498: break;
499: default: /* unknown switch value */
500: usage (vty);
501: return 1;
502: }
503: }
504: break;
505:
506: default: /* unknoun case */
507: usage (vty);
508: return 1;
509: }
510: }
511:
512:
513: return 0;
514: }
515:
516:
517: /* generator of layered networks for the shortest paths problem;
518: extended DIMACS format for output */
519: int
520: gen_spgrid_topology (struct vty *vty, struct list *topology)
521: {
522: /* ----- ajusting parameters ----- */
523:
524: /* spanning */
525: if ( cl < cm ) { lx = cl; cl = cm; cm = lx; }
526:
527: /* additional arcs */
528: if ( al < am ) { lx = al; al = am; am = lx; }
529:
530: /* interlayered arcs */
531: if ( il < im ) { lx = il; il = im; im = lx; }
532:
533: /* potential parameters */
534: if ( p_f )
535: {
536: if ( ! pl_f ) pl = il;
537: if ( ! pm_f ) pm = im;
538: if ( pl < pm ) { lx = pl; pl = pm; pm = lx; }
539: }
540:
541: /* number of nodes and arcs */
542:
543: n = (double)X *(double)Y + 1;
544:
545: m = (double)Y; /* arcs from source */
546:
547: switch ( cw )
548: {
549: case PATH:
550: mc = (double)Y - 1;
551: break;
552: case CYCLE:
553: mc = (double)Y;
554: break;
555: case DOUBLE_CYCLE:
556: mc = 2*(double)Y;
557: }
558:
559: m += (double)X * (double)mc; /* spanning arcs */
560: m += (double)X * (double)ax; /* additional arcs */
561:
562: /* interlayered arcs */
563: for ( x = 0; x < X; x ++ )
564: {
565: dl = ( ( X - x - 1 ) + ( ih - 1 ) ) / ih;
566: if ( dl > ix ) dl = ix;
567: m += (double)Y * (double)dl;
568: }
569:
570: /* artifical source parameters */
571: if ( s_f ) {
572: m += n; n ++ ;
573: if ( ! sm_f ) sm = sl;
574: if ( sl < sm ) { lx = sl; sl = sm; sm = lx; }
575: }
576:
577: if ( n >= (double)LONG_MAX || m >= (double)LONG_MAX )
578: {
579: zlog_err ("Too large problem. It can't be generated\n");
580: exit (4);
581: }
582: else
583: {
584: n0 = (long)n; m0 = (long)m;
585: }
586:
587: if ( ip_f )
588: mess = (long*) calloc ( Y, sizeof ( long ) );
589:
590: /* printing title */
591: zlog_info ("Generating topology for ISIS");
592:
593: source = ( s_f ) ? n0-1 : n0;
594:
595: if ( p_f ) /* generating potentials */ {
596: p = (long*) calloc ( n0+1, sizeof (long) );
597: seed1 = 2*seed + 1;
598: init_rand ( seed1);
599: pl = pl - pm + 1;
600:
601: for ( x = 0; x < X; x ++ )
602: for ( y = 0; y < Y; y ++ ) {
603: p_t = pm + nrand ( pl );
604: if ( pn_f ) p_t *= (long) ( (1 + x) * pn );
605: if ( ps_f ) p_t *= (long) ( (1 + x) * ( (1 + x) * ps ));
606:
607: p[ NODE ( x, y ) ] = p_t;
608: }
609: p[n0] = 0;
610: if ( s_f ) p[n0-1] = 0;
611: }
612:
613: if ( s_f ) /* additional arcs from artifical source */
614: {
615: seed2 = 3*seed + 1;
616: init_rand ( seed2 );
617: sl = sl - sm + 1;
618:
619: for ( x = X - 1; x >= 0; x -- )
620: for ( y = Y - 1; y >= 0; y -- )
621: {
622: i = NODE ( x, y );
623: s = sm + nrand ( sl );
624: print_arc (vty, topology, n0, i, s );
625: }
626:
627: print_arc (vty, topology, n0, n0-1, 0 );
628: }
629:
630:
631: /* ----- generating arcs within layers ----- */
632:
633: init_rand ( seed );
634: cl = cl - cm + 1;
635: al = al - am + 1;
636:
637: for ( x = 0; x < X; x ++ )
638: {
639: /* generating arcs within one layer */
640: for ( y = 0; y < Y-1; y ++ )
641: {
642: /* generating spanning graph */
643: i = NODE ( x, y );
644: j = NODE ( x, y+1 );
645: l = cm + nrand ( cl );
646: print_arc (vty, topology, i, j, l );
647:
648: if ( cw == DOUBLE_CYCLE )
649: {
650: l = cm + nrand ( cl );
651: print_arc (vty, topology, j, i, l );
652: }
653: }
654:
655: if ( cw <= CYCLE )
656: {
657: i = NODE ( x, Y-1 );
658: j = NODE ( x, 0 );
659: l = cm + nrand ( cl );
660: print_arc (vty, topology, i, j, l );
661:
662: if ( cw == DOUBLE_CYCLE )
663: {
664: l = cm + nrand ( cl );
665: print_arc (vty, topology, j, i, l );
666: }
667: }
668:
669: /* generating additional arcs */
670:
671: for ( k = ax; k > 0; k -- )
672: {
673: y1 = nrand ( Y );
674: do
675: y2 = nrand ( Y );
676: while ( y2 == y1 );
677: i = NODE ( x, y1 );
678: j = NODE ( x, y2 );
679: l = am + nrand ( al );
680: print_arc (vty, topology, i, j, l );
681: }
682: }
683:
684: /* ----- generating interlayered arcs ------ */
685:
686: il = il - im + 1;
687:
688: /* arcs from the source */
689:
690: for ( y = 0; y < Y; y ++ )
691: {
692: l = im + nrand ( il );
693: i = NODE ( 0, y );
694: print_arc (vty, topology, source, i, l );
695: }
696:
697: for ( x = 0; x < X-1; x ++ )
698: {
699: /* generating arcs from one layer */
700: for ( count = 0, xn = x + 1;
701: count < ix && xn < X;
702: count ++, xn += ih )
703: {
704: if ( ip_f )
705: for ( y = 0; y < Y; y ++ )
706: mess[y] = y;
707:
708: for ( y = 0; y < Y; y ++ )
709: {
710: i = NODE ( x, y );
711: dx = xn - x;
712: if ( ip_f )
713: {
714: yp = nrand(Y-y);
715: yn = mess[ yp ];
716: mess[ yp ] = mess[ Y - y - 1 ];
717: }
718: else
719: yn = y;
720: j = NODE ( xn, yn );
721: l = im + nrand ( il );
722: if ( in != 0 )
723: l *= (long) ( in * dx );
724: if ( is_f )
725: l *= (long) ( ( is * dx ) * dx );
726: print_arc (vty, topology, i, j, l );
727: }
728: }
729: }
730: /* all is done */
731: return ext;
732:
733: return 0;
734: }
735:
736:
737:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to spgrid.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / isisd / topology