src/sn_network.c

   1 /**
   2  * libsortnetwork - src/sn_network.c
   3  * Copyright (C) 2008-2010  Florian octo Forster
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; only version 2 of the License is applicable.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  * Authors:
  19  *   Florian octo Forster <ff at octo.it>
  20  **/
  21
  22 #ifndef _ISOC99_SOURCE
  23 # define _ISOC99_SOURCE
  24 #endif
  25 #ifndef _POSIX_C_SOURCE
  26 # define _POSIX_C_SOURCE 200112L
  27 #endif
  28
  29 #if 0
  30 # define DPRINTF(...) fprintf (stderr, "sn_network: " __VA_ARGS__)
  31 #else
  32 # define DPRINTF(...) /**/
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <strings.h>
  39 #include <ctype.h>
  40 #include <assert.h>
  41 #include <errno.h>
  42
  43 #include "sn_network.h"
  44 #include "sn_random.h"
  45
  46 sn_network_t *sn_network_create (int inputs_num) /* {{{ */
  47 {
  48   sn_network_t *n;
  49
  50   n = (sn_network_t *) malloc (sizeof (sn_network_t));
  51   if (n == NULL)
  52     return (NULL);
  53   memset (n, '\0', sizeof (sn_network_t));
  54
  55   n->inputs_num = inputs_num;
  56
  57   return (n);
  58 } /* }}} sn_network_t *sn_network_create */
  59
  60 void sn_network_destroy (sn_network_t *n) /* {{{ */
  61 {
  62   if (n == NULL)
  63     return;
  64
  65   if (n->stages != NULL)
  66   {
  67     int i;
  68     for (i = 0; i < n->stages_num; i++)
  69     {
  70       sn_stage_destroy (n->stages[i]);
  71       n->stages[i] = NULL;
  72     }
  73     free (n->stages);
  74     n->stages = NULL;
  75   }
  76
  77   free (n);
  78 } /* }}} void sn_network_destroy */
  79
  80 sn_network_t *sn_network_create_odd_even_mergesort (int inputs_num) /* {{{ */
  81 {
  82   sn_network_t *n;
  83
  84   n = sn_network_create (inputs_num);
  85
  86   assert (inputs_num > 0);
  87   if (inputs_num == 1)
  88   {
  89     return (n);
  90   }
  91   if (inputs_num == 2)
  92   {
  93     sn_stage_t *s;
  94     sn_comparator_t c;
  95
  96     c.min = 0;
  97     c.max = 1;
  98
  99     s = sn_stage_create (/* depth = */ 0);
 100     sn_stage_comparator_add (s, &c);
 101     sn_network_stage_add (n, s);
 102
 103     return (n);
 104   }
 105   else
 106   {
 107     sn_network_t *n_left;
 108     sn_network_t *n_right;
 109     int inputs_left;
 110     int inputs_right;
 111
 112     inputs_left = inputs_num / 2;
 113     inputs_right = inputs_num - inputs_left;
 114
 115     n_left = sn_network_create_odd_even_mergesort (inputs_left);
 116     if (n_left == NULL)
 117       return (NULL);
 118
 119     n_right = sn_network_create_odd_even_mergesort (inputs_right);
 120     if (n_right == NULL)
 121     {
 122       sn_network_destroy (n_left);
 123       return (NULL);
 124     }
 125
 126     n = sn_network_combine_odd_even_merge (n_left, n_right);
 127
 128     sn_network_destroy (n_left);
 129     sn_network_destroy (n_right);
 130
 131     if (n != NULL)
 132       sn_network_compress (n);
 133
 134     return (n);
 135   }
 136 } /* }}} sn_network_t *sn_network_create_odd_even_mergesort */
 137
 138 static int sn_network_create_pairwise_internal (sn_network_t *n, /* {{{ */
 139     int *inputs, int inputs_num)
 140 {
 141   int i;
 142   int inputs_copy[inputs_num];
 143   int m;
 144
 145   for (i = 1; i < inputs_num; i += 2)
 146   {
 147     sn_comparator_t *c = sn_comparator_create (inputs[i-1], inputs[i]);
 148     sn_network_comparator_add (n, c);
 149     sn_comparator_destroy (c);
 150   }
 151
 152   if (inputs_num <= 2)
 153     return (0);
 154
 155   /* Sort "pairs" recursively. Like with odd-even mergesort, odd and even lines
 156    * are handled recursively and later reunited. */
 157   for (i = 0; i < inputs_num; i += 2)
 158     inputs_copy[(int) (i / 2)] = inputs[i];
 159   /* Recursive call #1 with first set of lines */
 160   sn_network_create_pairwise_internal (n, inputs_copy,
 161       (int) ((inputs_num + 1) / 2));
 162
 163   for (i = 1; i < inputs_num; i += 2)
 164     inputs_copy[(int) (i / 2)] = inputs[i];
 165   /* Recursive call #2 with second set of lines */
 166   sn_network_create_pairwise_internal (n, inputs_copy,
 167       (int) (inputs_num/ 2));
 168
 169   /* m is the "amplitude" of the sorted pairs. This is a bit tricky to read due
 170    * to different indices being used in the paper, unfortunately. */
 171   m = inputs_num / 2;
 172   while (m > 1)
 173   {
 174     for (i = 1; (i + (m - 1)) < inputs_num; i += 2)
 175     {
 176       int left = i;
 177       int right = i + (m - 1);
 178       sn_comparator_t *c;
 179
 180       assert (left < right);
 181       c = sn_comparator_create (inputs[left], inputs[right]);
 182       sn_network_comparator_add (n, c);
 183       sn_comparator_destroy (c);
 184     }
 185
 186     m = m / 2;
 187   } /* while (m > 1) */
 188
 189   return (0);
 190 } /* }}} int sn_network_create_pairwise_internal */
 191
 192 sn_network_t *sn_network_create_pairwise (int inputs_num) /* {{{ */
 193 {
 194   sn_network_t *n = sn_network_create (inputs_num);
 195   int inputs[inputs_num];
 196   int i;
 197
 198   if (n == NULL)
 199     return (NULL);
 200
 201   for (i = 0; i < inputs_num; i++)
 202     inputs[i] = i;
 203
 204   sn_network_create_pairwise_internal (n, inputs, inputs_num);
 205   sn_network_compress (n);
 206
 207   return (n);
 208 } /* }}} sn_network_t *sn_network_create_pairwise */
 209
 210 int sn_network_network_add (sn_network_t *n, sn_network_t *other) /* {{{ */
 211 {
 212   int stages_num;
 213   sn_stage_t **tmp;
 214
 215   if ((n == NULL) || (other == NULL))
 216     return (EINVAL);
 217
 218   stages_num = n->stages_num + other->stages_num;
 219   if (stages_num <= n->stages_num)
 220     return (EINVAL);
 221
 222   tmp = realloc (n->stages, sizeof (*n->stages) * stages_num);
 223   if (tmp == NULL)
 224     return (ENOMEM);
 225   n->stages = tmp;
 226
 227   memcpy (n->stages + n->stages_num, other->stages,
 228       sizeof (*other->stages) * other->stages_num);
 229   n->stages_num = stages_num;
 230
 231   free (other->stages);
 232   free (other);
 233
 234   return (0);
 235 } /* }}} int sn_network_network_add */
 236
 237 int sn_network_stage_add (sn_network_t *n, sn_stage_t *s) /* {{{ */
 238 {
 239   sn_stage_t **temp;
 240
 241   if ((n == NULL) || (s == NULL))
 242     return (EINVAL);
 243
 244   temp = (sn_stage_t **) realloc (n->stages, (n->stages_num + 1)
 245       * sizeof (sn_stage_t *));
 246   if (temp == NULL)
 247     return (-1);
 248
 249   n->stages = temp;
 250   SN_STAGE_DEPTH (s) = n->stages_num;
 251   n->stages[n->stages_num] = s;
 252   n->stages_num++;
 253
 254   return (0);
 255 } /* }}} int sn_network_stage_add */
 256
 257 int sn_network_stage_remove (sn_network_t *n, int s_num) /* {{{ */
 258 {
 259   int nmemb = n->stages_num - (s_num + 1);
 260   sn_stage_t **temp;
 261
 262   if ((n == NULL) || (s_num >= n->stages_num))
 263     return (EINVAL);
 264
 265   sn_stage_destroy (n->stages[s_num]);
 266   n->stages[s_num] = NULL;
 267
 268   if (nmemb > 0)
 269   {
 270     memmove (n->stages + s_num, n->stages + (s_num + 1),
 271         nmemb * sizeof (sn_stage_t *));
 272     n->stages[n->stages_num - 1] = NULL;
 273   }
 274   n->stages_num--;
 275
 276   /* Free the unused memory */
 277   if (n->stages_num == 0)
 278   {
 279     free (n->stages);
 280     n->stages = NULL;
 281   }
 282   else
 283   {
 284     temp = (sn_stage_t **) realloc (n->stages,
 285         n->stages_num * sizeof (sn_stage_t *));
 286     if (temp == NULL)
 287       return (-1);
 288     n->stages = temp;
 289   }
 290
 291   return (0);
 292 } /* }}} int sn_network_stage_remove */
 293
 294 sn_network_t *sn_network_clone (const sn_network_t *n) /* {{{ */
 295 {
 296   sn_network_t *n_copy;
 297   int i;
 298
 299   n_copy = sn_network_create (n->inputs_num);
 300   if (n_copy == NULL)
 301     return (NULL);
 302
 303   for (i = 0; i < n->stages_num; i++)
 304   {
 305     sn_stage_t *s;
 306     int status;
 307
 308     s = sn_stage_clone (n->stages[i]);
 309     if (s == NULL)
 310       break;
 311
 312     status = sn_network_stage_add (n_copy, s);
 313     if (status != 0)
 314       break;
 315   }
 316
 317   if (i < n->stages_num)
 318   {
 319     sn_network_destroy (n_copy);
 320     return (NULL);
 321   }
 322
 323   return (n_copy);
 324 } /* }}} sn_network_t *sn_network_clone */
 325
 326 int sn_network_comparator_add (sn_network_t *n, /* {{{ */
 327     const sn_comparator_t *c)
 328 {
 329   sn_stage_t *s;
 330
 331   if ((n == NULL) || (c == NULL))
 332     return (EINVAL);
 333
 334   if (n->stages_num > 0)
 335   {
 336     s = n->stages[n->stages_num - 1];
 337
 338     if (sn_stage_comparator_check_conflict (s, c) == 0)
 339     {
 340       sn_stage_comparator_add (s, c);
 341       return (0);
 342     }
 343   }
 344
 345   s = sn_stage_create (n->stages_num);
 346   sn_stage_comparator_add (s, c);
 347   sn_network_stage_add (n, s);
 348
 349   return (0);
 350 } /* }}} int sn_network_comparator_add */
 351
 352 int sn_network_get_comparator_num (const sn_network_t *n) /* {{{ */
 353 {
 354   int num;
 355   int i;
 356
 357   if (n == NULL)
 358     return (-1);
 359
 360   num = 0;
 361   for (i = 0; i < n->stages_num; i++)
 362     num += n->stages[i]->comparators_num;
 363
 364   return (num);
 365 } /* }}} int sn_network_get_comparator_num */
 366
 367 int sn_network_show (sn_network_t *n) /* {{{ */
 368 {
 369   int i;
 370
 371   for (i = 0; i < n->stages_num; i++)
 372     sn_stage_show (n->stages[i]);
 373
 374   return (0);
 375 } /* }}} int sn_network_show */
 376
 377 int sn_network_invert (sn_network_t *n) /* {{{ */
 378 {
 379   int i;
 380
 381   if (n == NULL)
 382     return (EINVAL);
 383
 384   for (i = 0; i < n->stages_num; i++)
 385     sn_stage_invert (n->stages[i]);
 386
 387   return (0);
 388 } /* }}} int sn_network_invert */
 389
 390 int sn_network_shift (sn_network_t *n, int sw) /* {{{ */
 391 {
 392   int i;
 393
 394   if ((n == NULL) || (sw < 0))
 395     return (EINVAL);
 396
 397   if (sw == 0)
 398     return (0);
 399
 400   for (i = 0; i < n->stages_num; i++)
 401     sn_stage_shift (n->stages[i], sw, SN_NETWORK_INPUT_NUM (n));
 402
 403   return (0);
 404 } /* }}} int sn_network_shift */
 405
 406 int sn_network_compress (sn_network_t *n) /* {{{ */
 407 {
 408   int i;
 409   int j;
 410   int k;
 411
 412   for (i = 1; i < n->stages_num; i++)
 413   {
 414     sn_stage_t *s;
 415
 416     s = n->stages[i];
 417
 418     for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
 419     {
 420       sn_comparator_t *c = SN_STAGE_COMP_GET (s, j);
 421       int move_to = i;
 422
 423       for (k = i - 1; k >= 0; k--)
 424       {
 425         int conflict;
 426
 427         conflict = sn_stage_comparator_check_conflict (n->stages[k], c);
 428         if (conflict == 0)
 429         {
 430           move_to = k;
 431           continue;
 432         }
 433
 434         if (conflict == 2)
 435           move_to = -1;
 436         break;
 437       }
 438
 439       if (move_to < i)
 440       {
 441         if (move_to >= 0)
 442           sn_stage_comparator_add (n->stages[move_to], c);
 443         sn_stage_comparator_remove (s, j);
 444         j--;
 445       }
 446     }
 447   }
 448
 449   while ((n->stages_num > 0)
 450       && (SN_STAGE_COMP_NUM (n->stages[n->stages_num - 1]) == 0))
 451     sn_network_stage_remove (n, n->stages_num - 1);
 452
 453   return (0);
 454 } /* }}} int sn_network_compress */
 455
 456 int sn_network_normalize (sn_network_t *n) /* {{{ */
 457 {
 458   int i;
 459
 460   for (i = 0; i < n->stages_num; i++)
 461   {
 462     sn_stage_t *s;
 463     int j;
 464
 465     s = n->stages[i];
 466
 467     for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
 468     {
 469       sn_comparator_t *c;
 470       int min;
 471       int max;
 472
 473       c = SN_STAGE_COMP_GET (s, j);
 474
 475       min = c->min;
 476       max = c->max;
 477
 478       if (min > max)
 479       {
 480         int k;
 481
 482         for (k = i; k < n->stages_num; k++)
 483           sn_stage_swap (n->stages[k], min, max);
 484
 485         i = -1;
 486         break; /* for (j) */
 487       }
 488     } /* for (j = 0 .. #comparators) */
 489   } /* for (i = n->stages_num - 1 .. 0) */
 490
 491   return (0);
 492 } /* }}} int sn_network_normalize */
 493
 494 int sn_network_remove_input (sn_network_t *n, int input) /* {{{ */
 495 {
 496   int i;
 497
 498   if ((n == NULL) || (input < 0) || (input >= n->inputs_num))
 499     return (EINVAL);
 500
 501   for (i = 0; i < n->stages_num; i++)
 502     sn_stage_remove_input (n->stages[i], input);
 503
 504   n->inputs_num--;
 505
 506   return (0);
 507 } /* }}} int sn_network_remove_input */
 508
 509 int sn_network_cut_at (sn_network_t *n, int input, /* {{{ */
 510     enum sn_network_cut_dir_e dir)
 511 {
 512   int i;
 513   int position = input;
 514
 515   for (i = 0; i < n->stages_num; i++)
 516   {
 517     sn_stage_t *s;
 518     int new_position;
 519
 520     s = n->stages[i];
 521     new_position = sn_stage_cut_at (s, position, dir);
 522
 523     if (position != new_position)
 524     {
 525       int j;
 526
 527       for (j = 0; j < i; j++)
 528         sn_stage_swap (n->stages[j], position, new_position);
 529     }
 530
 531     position = new_position;
 532   }
 533
 534   assert (((dir == DIR_MIN) && (position == 0))
 535       || ((dir == DIR_MAX) && (position == (n->inputs_num - 1))));
 536
 537   sn_network_remove_input (n, position);
 538
 539   return (0);
 540 } /* }}} int sn_network_cut_at */
 541
 542 int sn_network_cut (sn_network_t *n, int *mask) /* {{{ */
 543 {
 544   int inputs_num;
 545   int i;
 546
 547   for (i = 0; i < n->stages_num; i++)
 548   {
 549     sn_stage_t *s = n->stages[i];
 550
 551     sn_stage_cut (s, mask, n->stages);
 552   }
 553
 554   /* Use a copy of this member since it will be updated by
 555    * sn_network_remove_input(). */
 556   inputs_num = n->inputs_num;
 557   for (i = 0; i < inputs_num; i++)
 558   {
 559     if (mask[i] < 0)
 560       sn_network_remove_input (n, 0);
 561     else if (mask[i] > 0)
 562       sn_network_remove_input (n, n->inputs_num - 1);
 563   }
 564
 565   return (0);
 566 } /* }}} int sn_network_cut */
 567
 568 /* sn_network_concatenate
 569  *
 570  * `Glues' two networks together, resulting in a comparator network with twice
 571  * as many inputs but one that doesn't really sort anymore. It produces a
 572  * bitonic sequence, though, that can be used by the mergers below. */
 573 static sn_network_t *sn_network_concatenate (sn_network_t *n0, /* {{{ */
 574     sn_network_t *n1)
 575 {
 576   sn_network_t *n;
 577   int stages_num;
 578   int i;
 579   int j;
 580
 581   stages_num = (n0->stages_num > n1->stages_num)
 582     ? n0->stages_num
 583     : n1->stages_num;
 584
 585   n = sn_network_create (n0->inputs_num + n1->inputs_num);
 586   if (n == NULL)
 587     return (NULL);
 588
 589   for (i = 0; i < stages_num; i++)
 590   {
 591     sn_stage_t *s = sn_stage_create (i);
 592
 593     if (i < n0->stages_num)
 594       for (j = 0; j < SN_STAGE_COMP_NUM (n0->stages[i]); j++)
 595       {
 596         sn_comparator_t *c = SN_STAGE_COMP_GET (n0->stages[i], j);
 597         sn_stage_comparator_add (s, c);
 598       }
 599
 600     if (i < n1->stages_num)
 601       for (j = 0; j < SN_STAGE_COMP_NUM (n1->stages[i]); j++)
 602       {
 603         sn_comparator_t *c_orig = SN_STAGE_COMP_GET (n1->stages[i], j);
 604         sn_comparator_t  c_copy;
 605
 606         SN_COMP_MIN(&c_copy) = SN_COMP_MIN(c_orig) + n0->inputs_num;
 607         SN_COMP_MAX(&c_copy) = SN_COMP_MAX(c_orig) + n0->inputs_num;
 608
 609         sn_stage_comparator_add (s, &c_copy);
 610       }
 611
 612     sn_network_stage_add (n, s);
 613   }
 614
 615   return (n);
 616 } /* }}} sn_network_t *sn_network_concatenate */
 617
 618 static int sn_network_add_bitonic_merger_recursive (sn_network_t *n, /* {{{ */
 619     int low, int num)
 620 {
 621   sn_stage_t *s;
 622   int m;
 623   int i;
 624
 625   if (num == 1)
 626     return (0);
 627
 628   s = sn_stage_create (n->stages_num);
 629   if (s == NULL)
 630     return (-1);
 631
 632   m = num / 2;
 633
 634   for (i = low; i < (low + m); i++)
 635   {
 636     sn_comparator_t c;
 637
 638     c.min = i;
 639     c.max = i + m;
 640
 641     sn_stage_comparator_add (s, &c);
 642   }
 643
 644   sn_network_stage_add (n, s);
 645
 646   sn_network_add_bitonic_merger_recursive (n, low, m);
 647   sn_network_add_bitonic_merger_recursive (n, low + m, m);
 648
 649   return (0);
 650 } /* }}} int sn_network_add_bitonic_merger_recursive */
 651
 652 static int sn_network_add_bitonic_merger (sn_network_t *n) /* {{{ */
 653 {
 654 #if 0
 655   sn_stage_t *s;
 656   int m;
 657   int i;
 658
 659   s = sn_stage_create (n->stages_num);
 660   if (s == NULL)
 661     return (-1);
 662
 663   m = n->inputs_num / 2;
 664
 665   for (i = 0; i < m; i++)
 666   {
 667     sn_comparator_t c;
 668
 669     c.min = i;
 670     c.max = n->inputs_num - (i + 1);
 671
 672     sn_stage_comparator_add (s, &c);
 673   }
 674
 675   sn_network_stage_add (n, s);
 676
 677   sn_network_add_bitonic_merger_recursive (n, 0, m);
 678   sn_network_add_bitonic_merger_recursive (n, m, m);
 679 #else
 680   sn_network_add_bitonic_merger_recursive (n, 0, SN_NETWORK_INPUT_NUM (n));
 681 #endif
 682
 683   return (0);
 684 } /* }}} int sn_network_add_bitonic_merger */
 685
 686 static int sn_network_add_odd_even_merger (sn_network_t *n, /* {{{ */
 687     int *indizes_left, int indizes_left_num,
 688     int *indizes_right, int indizes_right_num)
 689 {
 690   int tmp_left[indizes_left_num];
 691   int tmp_left_num;
 692   int tmp_right[indizes_left_num];
 693   int tmp_right_num;
 694   int max_index;
 695   sn_stage_t *s;
 696   int i;
 697
 698   if ((indizes_left_num == 0) || (indizes_right_num == 0))
 699   {
 700     return (0);
 701   }
 702   else if ((indizes_left_num == 1) && (indizes_right_num == 1))
 703   {
 704     sn_comparator_t c;
 705     sn_stage_t *s;
 706
 707     c.min = *indizes_left;
 708     c.max = *indizes_right;
 709
 710     s = sn_stage_create (n->stages_num);
 711     if (s == NULL)
 712       return (-1);
 713
 714     sn_stage_comparator_add (s, &c);
 715     sn_network_stage_add (n, s);
 716
 717     return (0);
 718   }
 719
 720   /* Merge odd sequences */
 721   tmp_left_num = (indizes_left_num + 1) / 2;
 722   for (i = 0; i < tmp_left_num; i++)
 723     tmp_left[i] = indizes_left[2 * i];
 724
 725   tmp_right_num = (indizes_right_num + 1) / 2;
 726   for (i = 0; i < tmp_right_num; i++)
 727     tmp_right[i] = indizes_right[2 * i];
 728
 729   sn_network_add_odd_even_merger (n,
 730       tmp_left, tmp_left_num,
 731       tmp_right, tmp_right_num);
 732
 733   /* Merge even sequences */
 734   tmp_left_num = indizes_left_num / 2;
 735   for (i = 0; i < tmp_left_num; i++)
 736     tmp_left[i] = indizes_left[(2 * i) + 1];
 737
 738   tmp_right_num = indizes_right_num / 2;
 739   for (i = 0; i < tmp_right_num; i++)
 740     tmp_right[i] = indizes_right[(2 * i) + 1];
 741
 742   sn_network_add_odd_even_merger (n,
 743       tmp_left, tmp_left_num,
 744       tmp_right, tmp_right_num);
 745
 746   /* Apply ``comparison-interchange'' operations. */
 747   s = sn_stage_create (n->stages_num);
 748
 749   max_index = indizes_left_num + indizes_right_num;
 750   if ((max_index % 2) == 0)
 751     max_index -= 3;
 752   else
 753     max_index -= 2;
 754
 755   for (i = 1; i <= max_index; i += 2)
 756   {
 757     sn_comparator_t c;
 758
 759     if (i < indizes_left_num)
 760       c.min = indizes_left[i];
 761     else
 762       c.min = indizes_right[i - indizes_left_num];
 763
 764     if ((i + 1) < indizes_left_num)
 765       c.max = indizes_left[i + 1];
 766     else
 767       c.max = indizes_right[i + 1 - indizes_left_num];
 768
 769     sn_stage_comparator_add (s, &c);
 770   }
 771
 772   sn_network_stage_add (n, s);
 773
 774   return (0);
 775 } /* }}} int sn_network_add_odd_even_merger */
 776
 777 static sn_network_t *sn_network_combine_bitonic_shift (sn_network_t *n0, /* {{{ */
 778     sn_network_t *n1, int do_shift)
 779 {
 780   sn_network_t *n;
 781   sn_network_t *n1_clone;
 782   int shift;
 783
 784   n1_clone = sn_network_clone (n1);
 785   if (n1_clone == NULL)
 786     return (NULL);
 787
 788   sn_network_invert (n1_clone);
 789
 790   n = sn_network_concatenate (n0, n1_clone);
 791   if (n == NULL)
 792     return (NULL);
 793
 794   sn_network_destroy (n1_clone);
 795
 796   if (do_shift)
 797     shift = sn_bounded_random (0, SN_NETWORK_INPUT_NUM (n) - 1);
 798   else
 799     shift = 0;
 800
 801   if (shift > 0)
 802   {
 803     DPRINTF ("sn_network_combine_bitonic_shift: Shifting by %i.\n", shift);
 804     sn_network_shift (n, shift);
 805   }
 806
 807   sn_network_add_bitonic_merger (n);
 808
 809   return (n);
 810 } /* }}} sn_network_t *sn_network_combine_bitonic_shift */
 811
 812 sn_network_t *sn_network_combine_bitonic_merge (sn_network_t *n0, /* {{{ */
 813     sn_network_t *n1)
 814 {
 815   return (sn_network_combine_bitonic_shift (n0, n1, /* do_shift = */ 0));
 816 } /* }}} sn_network_t *sn_network_combine_bitonic_merge */
 817
 818 sn_network_t *sn_network_combine_odd_even_merge (sn_network_t *n0, /* {{{ */
 819     sn_network_t *n1)
 820 {
 821   sn_network_t *n;
 822   int indizes_left[n0->inputs_num];
 823   int indizes_left_num;
 824   int indizes_right[n1->inputs_num];
 825   int indizes_right_num;
 826   int status;
 827   int i;
 828
 829   indizes_left_num = n0->inputs_num;
 830   indizes_right_num = n1->inputs_num;
 831   for (i = 0; i < indizes_left_num; i++)
 832     indizes_left[i] = i;
 833   for (i = 0; i < indizes_right_num; i++)
 834     indizes_right[i] = indizes_left_num + i;
 835
 836   n = sn_network_concatenate (n0, n1);
 837   if (n == NULL)
 838     return (NULL);
 839
 840   status = sn_network_add_odd_even_merger (n,
 841       indizes_left, indizes_left_num,
 842       indizes_right, indizes_right_num);
 843   if (status != 0)
 844   {
 845     sn_network_destroy (n);
 846     return (NULL);
 847   }
 848
 849   sn_network_compress (n);
 850   return (n);
 851 } /* }}} sn_network_t *sn_network_combine_odd_even_merge */
 852
 853 sn_network_t *sn_network_combine (sn_network_t *n0, /* {{{ */
 854     sn_network_t *n1)
 855 {
 856   return (sn_network_combine_odd_even_merge (n0, n1));
 857 } /* }}} sn_network_t *sn_network_combine */
 858
 859 int sn_network_sort (sn_network_t *n, int *values) /* {{{ */
 860 {
 861   int status;
 862   int i;
 863
 864   status = 0;
 865   for (i = 0; i < n->stages_num; i++)
 866   {
 867     status = sn_stage_sort (n->stages[i], values);
 868     if (status != 0)
 869       return (status);
 870   }
 871
 872   return (status);
 873 } /* }}} int sn_network_sort */
 874
 875 int sn_network_brute_force_check (sn_network_t *n) /* {{{ */
 876 {
 877   int test_pattern[n->inputs_num];
 878   int values[n->inputs_num];
 879   int status;
 880   int i;
 881
 882   memset (test_pattern, 0, sizeof (test_pattern));
 883   while (42)
 884   {
 885     int previous;
 886     int overflow;
 887
 888     /* Copy the current pattern and let the network sort it */
 889     memcpy (values, test_pattern, sizeof (values));
 890     status = sn_network_sort (n, values);
 891     if (status != 0)
 892       return (status);
 893
 894     /* Check if the array is now sorted. */
 895     previous = values[0];
 896     for (i = 1; i < n->inputs_num; i++)
 897     {
 898       if (previous > values[i])
 899         return (1);
 900       previous = values[i];
 901     }
 902
 903     /* Generate the next test pattern */
 904     overflow = 1;
 905     for (i = 0; i < n->inputs_num; i++)
 906     {
 907       if (test_pattern[i] == 0)
 908       {
 909         test_pattern[i] = 1;
 910         overflow = 0;
 911         break;
 912       }
 913       else
 914       {
 915         test_pattern[i] = 0;
 916         overflow = 1;
 917       }
 918     }
 919
 920     /* Break out of the while loop if we tested all possible patterns */
 921     if (overflow == 1)
 922       break;
 923   } /* while (42) */
 924
 925   /* All tests successfull */
 926   return (0);
 927 } /* }}} int sn_network_brute_force_check */
 928
 929 sn_network_t *sn_network_read (FILE *fh) /* {{{ */
 930 {
 931   sn_network_t *n;
 932   char buffer[64];
 933
 934   int opt_inputs = 0;
 935
 936   while (fgets (buffer, sizeof (buffer), fh) != NULL)
 937   {
 938     char *str_key = buffer;
 939     char *str_value = NULL;
 940     int   buffer_len = strlen (buffer);
 941
 942     while ((buffer_len > 0) && ((buffer[buffer_len - 1] == '\n')
 943           || (buffer[buffer_len - 1] == '\r')))
 944     {
 945       buffer_len--;
 946       buffer[buffer_len] = '\0';
 947     }
 948     if (buffer_len == 0)
 949       break;
 950
 951     str_value = strchr (buffer, ':');
 952     if (str_value == NULL)
 953     {
 954       printf ("Cannot parse line: %s\n", buffer);
 955       continue;
 956     }
 957
 958     *str_value = '\0'; str_value++;
 959     while ((*str_value != '\0') && (isspace (*str_value) != 0))
 960       str_value++;
 961
 962     if (strcasecmp ("Inputs", str_key) == 0)
 963       opt_inputs = atoi (str_value);
 964     else
 965       printf ("Unknown key: %s\n", str_key);
 966   } /* while (fgets) */
 967
 968   if (opt_inputs < 2)
 969     return (NULL);
 970
 971   n = sn_network_create (opt_inputs);
 972
 973   while (42)
 974   {
 975     sn_stage_t *s;
 976
 977     s = sn_stage_read (fh);
 978     if (s == NULL)
 979       break;
 980
 981     sn_network_stage_add (n, s);
 982   }
 983
 984   if (SN_NETWORK_STAGE_NUM (n) < 1)
 985   {
 986     sn_network_destroy (n);
 987     return (NULL);
 988   }
 989
 990   return (n);
 991 } /* }}} sn_network_t *sn_network_read */
 992
 993 sn_network_t *sn_network_read_file (const char *file) /* {{{ */
 994 {
 995   sn_network_t *n;
 996   FILE *fh;
 997
 998   fh = fopen (file, "r");
 999   if (fh == NULL)
1000     return (NULL);
1001
1002   n = sn_network_read (fh);
1003
1004   fclose (fh);
1005
1006   return (n);
1007 } /* }}} sn_network_t *sn_network_read_file */
1008
1009 int sn_network_write (sn_network_t *n, FILE *fh) /* {{{ */
1010 {
1011   int i;
1012
1013   fprintf (fh, "Inputs: %i\n", n->inputs_num);
1014   fprintf (fh, "\n");
1015
1016   for (i = 0; i < n->stages_num; i++)
1017     sn_stage_write (n->stages[i], fh);
1018
1019   return (0);
1020 } /* }}} int sn_network_write */
1021
1022 int sn_network_write_file (sn_network_t *n, const char *file) /* {{{ */
1023 {
1024   int status;
1025   FILE *fh;
1026
1027   fh = fopen (file, "w");
1028   if (fh == NULL)
1029     return (-1);
1030
1031   status = sn_network_write (n, fh);
1032
1033   fclose (fh);
1034
1035   return (status);
1036 } /* }}} int sn_network_write_file */
1037
1038 int sn_network_serialize (sn_network_t *n, char **ret_buffer, /* {{{ */
1039     size_t *ret_buffer_size)
1040 {
1041   char *buffer;
1042   size_t buffer_size;
1043   int status;
1044   int i;
1045
1046   buffer = *ret_buffer;
1047   buffer_size = *ret_buffer_size;
1048
1049 #define SNPRINTF_OR_FAIL(...) \
1050   status = snprintf (buffer, buffer_size, __VA_ARGS__); \
1051   if ((status < 1) || (((size_t) status) >= buffer_size)) \
1052     return (-1); \
1053   buffer += status; \
1054   buffer_size -= status;
1055
1056   SNPRINTF_OR_FAIL ("Inputs: %i\r\n\r\n", n->inputs_num);
1057
1058   for (i = 0; i < n->stages_num; i++)
1059   {
1060     status = sn_stage_serialize (n->stages[i], &buffer, &buffer_size);
1061     if (status != 0)
1062       return (status);
1063   }
1064
1065   *ret_buffer = buffer;
1066   *ret_buffer_size = buffer_size;
1067   return (0);
1068 } /* }}} int sn_network_serialize */
1069
1070 sn_network_t *sn_network_unserialize (char *buffer, /* {{{ */
1071     size_t buffer_size)
1072 {
1073   sn_network_t *n;
1074   int opt_inputs = 0;
1075
1076   if (buffer_size == 0)
1077     return (NULL);
1078
1079   /* Read options first */
1080   while (buffer_size > 0)
1081   {
1082     char *endptr;
1083     char *str_key;
1084     char *str_value;
1085     char *line;
1086     int   line_len;
1087
1088     line = buffer;
1089     endptr = strchr (buffer, '\n');
1090     if (endptr == NULL)
1091       return (NULL);
1092
1093     *endptr = 0;
1094     endptr++;
1095     buffer = endptr;
1096     line_len = strlen (line);
1097
1098     if ((line_len > 0) && (line[line_len - 1] == '\r'))
1099     {
1100       line[line_len - 1] = 0;
1101       line_len--;
1102     }
1103
1104     if (line_len == 0)
1105       break;
1106
1107     str_key = line;
1108     str_value = strchr (line, ':');
1109     if (str_value == NULL)
1110     {
1111       printf ("Cannot parse line: %s\n", line);
1112       continue;
1113     }
1114
1115     *str_value = '\0'; str_value++;
1116     while ((*str_value != '\0') && (isspace (*str_value) != 0))
1117       str_value++;
1118
1119     if (strcasecmp ("Inputs", str_key) == 0)
1120       opt_inputs = atoi (str_value);
1121     else
1122       printf ("Unknown key: %s\n", str_key);
1123   } /* while (fgets) */
1124
1125   if (opt_inputs < 2)
1126     return (NULL);
1127
1128   n = sn_network_create (opt_inputs);
1129
1130   while (42)
1131   {
1132     sn_stage_t *s;
1133
1134     s = sn_stage_unserialize (&buffer, &buffer_size);
1135     if (s == NULL)
1136       break;
1137
1138     sn_network_stage_add (n, s);
1139   }
1140
1141   if (SN_NETWORK_STAGE_NUM (n) < 1)
1142   {
1143     sn_network_destroy (n);
1144     return (NULL);
1145   }
1146
1147   return (n);
1148 } /* }}} sn_network_t *sn_network_unserialize */
1149
1150 /* vim: set sw=2 sts=2 et fdm=marker : */