2 * libsortnetwork - src/sn_network.c
3 * Copyright (C) 2008-2010 Florian octo Forster
5 * This library is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU Lesser General Public License as published by
7 * the Free Software Foundation; either version 2.1 of the License, or (at
8 * your option) any later version.
10 * This library is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
15 * You should have received a copy of the GNU Lesser General Public License
16 * along with this library; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 * Florian octo Forster <ff at octo.it>
23 #ifndef _ISOC99_SOURCE
24 # define _ISOC99_SOURCE
26 #ifndef _POSIX_C_SOURCE
27 # define _POSIX_C_SOURCE 200112L
31 # define DPRINTF(...) fprintf (stderr, "sn_network: " __VA_ARGS__)
33 # define DPRINTF(...) /**/
44 #include "sn_network.h"
45 #include "sn_random.h"
47 sn_network_t *sn_network_create (int inputs_num) /* {{{ */
51 n = (sn_network_t *) malloc (sizeof (sn_network_t));
54 memset (n, '\0', sizeof (sn_network_t));
56 n->inputs_num = inputs_num;
59 } /* }}} sn_network_t *sn_network_create */
61 void sn_network_destroy (sn_network_t *n) /* {{{ */
66 if (n->stages != NULL)
69 for (i = 0; i < n->stages_num; i++)
71 sn_stage_destroy (n->stages[i]);
79 } /* }}} void sn_network_destroy */
81 sn_network_t *sn_network_create_odd_even_mergesort (int inputs_num) /* {{{ */
85 assert (inputs_num > 0);
88 return (sn_network_create (inputs_num));
94 n = sn_network_create (inputs_num);
96 memset (&c, 0, sizeof (c));
100 sn_network_comparator_add (n, &c);
106 sn_network_t *n_left;
107 sn_network_t *n_right;
111 inputs_left = inputs_num / 2;
112 inputs_right = inputs_num - inputs_left;
114 n_left = sn_network_create_odd_even_mergesort (inputs_left);
118 n_right = sn_network_create_odd_even_mergesort (inputs_right);
121 sn_network_destroy (n_left);
125 n = sn_network_combine_odd_even_merge (n_left, n_right);
127 sn_network_destroy (n_left);
128 sn_network_destroy (n_right);
131 sn_network_compress (n);
135 } /* }}} sn_network_t *sn_network_create_odd_even_mergesort */
137 sn_network_t *sn_network_create_bitonic_mergesort (int inputs_num) /* {{{ */
141 assert (inputs_num > 0);
144 return (sn_network_create (inputs_num));
150 n = sn_network_create (inputs_num);
152 memset (&c, 0, sizeof (c));
156 sn_network_comparator_add (n, &c);
162 sn_network_t *n_left;
163 sn_network_t *n_right;
167 inputs_left = inputs_num / 2;
168 inputs_right = inputs_num - inputs_left;
170 n_left = sn_network_create_bitonic_mergesort (inputs_left);
174 if (inputs_left != inputs_right)
175 n_right = sn_network_create_bitonic_mergesort (inputs_right);
180 sn_network_destroy (n_left);
184 n = sn_network_combine_bitonic_merge (n_left, n_right);
186 if (n_left != n_right)
187 sn_network_destroy (n_right);
188 sn_network_destroy (n_left);
191 sn_network_compress (n);
195 } /* }}} sn_network_t *sn_network_create_bitonic_mergesort */
197 static int sn_network_create_pairwise_internal (sn_network_t *n, /* {{{ */
198 int *inputs, int inputs_num)
201 int inputs_copy[inputs_num];
204 for (i = 1; i < inputs_num; i += 2)
206 sn_comparator_t *c = sn_comparator_create (inputs[i-1], inputs[i]);
207 sn_network_comparator_add (n, c);
208 sn_comparator_destroy (c);
214 /* Sort "pairs" recursively. Like with odd-even mergesort, odd and even lines
215 * are handled recursively and later reunited. */
216 for (i = 0; i < inputs_num; i += 2)
217 inputs_copy[(int) (i / 2)] = inputs[i];
218 /* Recursive call #1 with first set of lines */
219 sn_network_create_pairwise_internal (n, inputs_copy,
220 (int) ((inputs_num + 1) / 2));
222 for (i = 1; i < inputs_num; i += 2)
223 inputs_copy[(int) (i / 2)] = inputs[i];
224 /* Recursive call #2 with second set of lines */
225 sn_network_create_pairwise_internal (n, inputs_copy,
226 (int) (inputs_num / 2));
228 /* m is the "amplitude" of the sorted pairs. This is a bit tricky to read due
229 * to different indices being used in the paper, unfortunately. */
230 m = (inputs_num + 1) / 2;
235 /* len = ((int) ((m + 1) / 2)) * 2 - 1; */
241 for (i = 1; (i + len) < inputs_num; i += 2)
247 assert (left < right);
248 c = sn_comparator_create (inputs[left], inputs[right]);
249 sn_network_comparator_add (n, c);
250 sn_comparator_destroy (c);
254 } /* while (m > 1) */
257 } /* }}} int sn_network_create_pairwise_internal */
259 sn_network_t *sn_network_create_pairwise (int inputs_num) /* {{{ */
261 sn_network_t *n = sn_network_create (inputs_num);
262 int inputs[inputs_num];
268 for (i = 0; i < inputs_num; i++)
271 sn_network_create_pairwise_internal (n, inputs, inputs_num);
272 sn_network_compress (n);
275 } /* }}} sn_network_t *sn_network_create_pairwise */
277 int sn_network_network_add (sn_network_t *n, sn_network_t *other) /* {{{ */
283 if ((n == NULL) || (other == NULL))
286 stages_num = n->stages_num + other->stages_num;
287 if (stages_num <= n->stages_num)
290 tmp = realloc (n->stages, sizeof (*n->stages) * stages_num);
295 memcpy (n->stages + n->stages_num, other->stages,
296 sizeof (*other->stages) * other->stages_num);
297 for (i = n->stages_num; i < stages_num; i++)
298 SN_STAGE_DEPTH(n->stages[i]) = i;
300 n->stages_num = stages_num;
302 free (other->stages);
306 } /* }}} int sn_network_network_add */
308 int sn_network_stage_add (sn_network_t *n, sn_stage_t *s) /* {{{ */
312 if ((n == NULL) || (s == NULL))
315 temp = (sn_stage_t **) realloc (n->stages, (n->stages_num + 1)
316 * sizeof (sn_stage_t *));
321 SN_STAGE_DEPTH (s) = n->stages_num;
322 n->stages[n->stages_num] = s;
326 } /* }}} int sn_network_stage_add */
328 int sn_network_stage_remove (sn_network_t *n, int s_num) /* {{{ */
330 int nmemb = n->stages_num - (s_num + 1);
333 if ((n == NULL) || (s_num >= n->stages_num))
336 sn_stage_destroy (n->stages[s_num]);
337 n->stages[s_num] = NULL;
341 memmove (n->stages + s_num, n->stages + (s_num + 1),
342 nmemb * sizeof (sn_stage_t *));
343 n->stages[n->stages_num - 1] = NULL;
347 /* Free the unused memory */
348 if (n->stages_num == 0)
355 temp = (sn_stage_t **) realloc (n->stages,
356 n->stages_num * sizeof (sn_stage_t *));
363 } /* }}} int sn_network_stage_remove */
365 sn_network_t *sn_network_clone (const sn_network_t *n) /* {{{ */
367 sn_network_t *n_copy;
370 n_copy = sn_network_create (n->inputs_num);
374 for (i = 0; i < n->stages_num; i++)
379 s = sn_stage_clone (n->stages[i]);
383 status = sn_network_stage_add (n_copy, s);
388 if (i < n->stages_num)
390 sn_network_destroy (n_copy);
395 } /* }}} sn_network_t *sn_network_clone */
397 int sn_network_comparator_add (sn_network_t *n, /* {{{ */
398 const sn_comparator_t *c)
402 if ((n == NULL) || (c == NULL))
405 if (n->stages_num > 0)
407 s = n->stages[n->stages_num - 1];
409 if (sn_stage_comparator_check_conflict (s, c) == 0)
411 sn_stage_comparator_add (s, c);
416 s = sn_stage_create (n->stages_num);
417 sn_stage_comparator_add (s, c);
418 sn_network_stage_add (n, s);
421 } /* }}} int sn_network_comparator_add */
423 int sn_network_get_comparator_num (const sn_network_t *n) /* {{{ */
432 for (i = 0; i < n->stages_num; i++)
433 num += n->stages[i]->comparators_num;
436 } /* }}} int sn_network_get_comparator_num */
438 int sn_network_show_fh (sn_network_t *n, FILE *fh) /* {{{ */
442 for (i = 0; i < n->stages_num; i++)
443 sn_stage_show_fh (n->stages[i], fh);
446 } /* }}} int sn_network_show_fh */
448 int sn_network_show (sn_network_t *n) /* {{{ */
450 return (sn_network_show_fh (n, stdout));
451 } /* }}} int sn_network_show */
453 int sn_network_invert (sn_network_t *n) /* {{{ */
460 for (i = 0; i < n->stages_num; i++)
461 sn_stage_invert (n->stages[i]);
464 } /* }}} int sn_network_invert */
466 int sn_network_shift (sn_network_t *n, int sw) /* {{{ */
470 if ((n == NULL) || (sw < 0))
476 for (i = 0; i < n->stages_num; i++)
477 sn_stage_shift (n->stages[i], sw, SN_NETWORK_INPUT_NUM (n));
480 } /* }}} int sn_network_shift */
482 int sn_network_compress (sn_network_t *n) /* {{{ */
488 for (i = 1; i < n->stages_num; i++)
494 for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
496 sn_comparator_t *c = SN_STAGE_COMP_GET (s, j);
499 for (k = i - 1; k >= 0; k--)
503 conflict = sn_stage_comparator_check_conflict (n->stages[k], c);
518 sn_stage_comparator_add (n->stages[move_to], c);
519 sn_stage_comparator_remove (s, j);
525 while ((n->stages_num > 0)
526 && (SN_STAGE_COMP_NUM (n->stages[n->stages_num - 1]) == 0))
527 sn_network_stage_remove (n, n->stages_num - 1);
530 } /* }}} int sn_network_compress */
532 int sn_network_normalize (sn_network_t *n) /* {{{ */
536 for (i = 0; i < n->stages_num; i++)
543 for (j = 0; j < SN_STAGE_COMP_NUM (s); j++)
549 c = SN_STAGE_COMP_GET (s, j);
558 for (k = i; k < n->stages_num; k++)
559 sn_stage_swap (n->stages[k], min, max);
564 } /* for (j = 0 .. #comparators) */
565 } /* for (i = n->stages_num - 1 .. 0) */
568 } /* }}} int sn_network_normalize */
570 int sn_network_unify (sn_network_t *n) /* {{{ */
577 sn_network_normalize (n);
578 sn_network_compress (n);
580 for (i = 0; i < n->stages_num; i++)
581 sn_stage_unify (n->stages[i]);
584 } /* }}} int sn_network_unify */
586 int sn_network_remove_input (sn_network_t *n, int input) /* {{{ */
590 if ((n == NULL) || (input < 0) || (input >= n->inputs_num))
593 for (i = 0; i < n->stages_num; i++)
594 sn_stage_remove_input (n->stages[i], input);
599 } /* }}} int sn_network_remove_input */
601 int sn_network_cut_at (sn_network_t *n, int input, /* {{{ */
602 enum sn_network_cut_dir_e dir)
605 int position = input;
607 for (i = 0; i < n->stages_num; i++)
613 new_position = sn_stage_cut_at (s, position, dir);
615 if (position != new_position)
619 for (j = 0; j < i; j++)
620 sn_stage_swap (n->stages[j], position, new_position);
623 position = new_position;
626 assert (((dir == DIR_MIN) && (position == 0))
627 || ((dir == DIR_MAX) && (position == (n->inputs_num - 1))));
629 sn_network_remove_input (n, position);
632 } /* }}} int sn_network_cut_at */
634 int sn_network_cut (sn_network_t *n, int *mask) /* {{{ */
639 for (i = 0; i < n->stages_num; i++)
641 sn_stage_t *s = n->stages[i];
643 sn_stage_cut (s, mask, n->stages);
646 /* Use a copy of this member since it will be updated by
647 * sn_network_remove_input(). */
648 inputs_num = n->inputs_num;
649 for (i = 0; i < inputs_num; i++)
652 sn_network_remove_input (n, 0);
653 else if (mask[i] > 0)
654 sn_network_remove_input (n, n->inputs_num - 1);
658 } /* }}} int sn_network_cut */
660 /* sn_network_concatenate
662 * `Glues' two networks together, resulting in a comparator network with twice
663 * as many inputs but one that doesn't really sort anymore. It produces a
664 * bitonic sequence, though, that can be used by the mergers below. */
665 static sn_network_t *sn_network_concatenate (sn_network_t *n0, /* {{{ */
673 stages_num = (n0->stages_num > n1->stages_num)
677 n = sn_network_create (n0->inputs_num + n1->inputs_num);
681 for (i = 0; i < stages_num; i++)
683 sn_stage_t *s = sn_stage_create (i);
685 if (i < n0->stages_num)
686 for (j = 0; j < SN_STAGE_COMP_NUM (n0->stages[i]); j++)
688 sn_comparator_t *c = SN_STAGE_COMP_GET (n0->stages[i], j);
689 sn_stage_comparator_add (s, c);
692 if (i < n1->stages_num)
693 for (j = 0; j < SN_STAGE_COMP_NUM (n1->stages[i]); j++)
695 sn_comparator_t *c_orig = SN_STAGE_COMP_GET (n1->stages[i], j);
696 sn_comparator_t c_copy;
698 SN_COMP_MIN(&c_copy) = SN_COMP_MIN(c_orig) + n0->inputs_num;
699 SN_COMP_MAX(&c_copy) = SN_COMP_MAX(c_orig) + n0->inputs_num;
701 sn_stage_comparator_add (s, &c_copy);
704 sn_network_stage_add (n, s);
708 } /* }}} sn_network_t *sn_network_concatenate */
710 static int sn_network_add_bitonic_merger (sn_network_t *n, /* {{{ */
711 int *indizes, int indizes_num)
715 if (indizes_num <= 1)
720 int even_indizes[indizes_num];
721 int even_indizes_num;
722 int odd_indizes[indizes_num];
725 even_indizes_num = (indizes_num + 1) / 2;
726 odd_indizes_num = indizes_num / 2;
728 for (i = 0; i < even_indizes_num; i++)
729 even_indizes[i] = indizes[2 * i];
730 for (i = 0; i < odd_indizes_num; i++)
731 odd_indizes[i] = indizes[(2 * i) + 1];
733 sn_network_add_bitonic_merger (n, even_indizes, even_indizes_num);
734 sn_network_add_bitonic_merger (n, odd_indizes, odd_indizes_num);
737 for (i = 1; i < indizes_num; i += 2)
741 memset (&c, 0, sizeof (c));
742 c.min = indizes[i - 1];
745 sn_network_comparator_add (n, &c);
749 } /* }}} int sn_network_add_bitonic_merger */
751 static int sn_network_add_odd_even_merger (sn_network_t *n, /* {{{ */
752 int *indizes_left, int indizes_left_num,
753 int *indizes_right, int indizes_right_num)
755 int tmp_left[indizes_left_num];
757 int tmp_right[indizes_left_num];
763 if ((indizes_left_num == 0) || (indizes_right_num == 0))
767 else if ((indizes_left_num == 1) && (indizes_right_num == 1))
772 c.min = *indizes_left;
773 c.max = *indizes_right;
775 s = sn_stage_create (n->stages_num);
779 sn_stage_comparator_add (s, &c);
780 sn_network_stage_add (n, s);
785 /* Merge odd sequences */
786 tmp_left_num = (indizes_left_num + 1) / 2;
787 for (i = 0; i < tmp_left_num; i++)
788 tmp_left[i] = indizes_left[2 * i];
790 tmp_right_num = (indizes_right_num + 1) / 2;
791 for (i = 0; i < tmp_right_num; i++)
792 tmp_right[i] = indizes_right[2 * i];
794 sn_network_add_odd_even_merger (n,
795 tmp_left, tmp_left_num,
796 tmp_right, tmp_right_num);
798 /* Merge even sequences */
799 tmp_left_num = indizes_left_num / 2;
800 for (i = 0; i < tmp_left_num; i++)
801 tmp_left[i] = indizes_left[(2 * i) + 1];
803 tmp_right_num = indizes_right_num / 2;
804 for (i = 0; i < tmp_right_num; i++)
805 tmp_right[i] = indizes_right[(2 * i) + 1];
807 sn_network_add_odd_even_merger (n,
808 tmp_left, tmp_left_num,
809 tmp_right, tmp_right_num);
811 /* Apply ``comparison-interchange'' operations. */
812 s = sn_stage_create (n->stages_num);
814 max_index = indizes_left_num + indizes_right_num;
815 if ((max_index % 2) == 0)
820 for (i = 1; i <= max_index; i += 2)
824 if (i < indizes_left_num)
825 c.min = indizes_left[i];
827 c.min = indizes_right[i - indizes_left_num];
829 if ((i + 1) < indizes_left_num)
830 c.max = indizes_left[i + 1];
832 c.max = indizes_right[i + 1 - indizes_left_num];
834 sn_stage_comparator_add (s, &c);
837 sn_network_stage_add (n, s);
840 } /* }}} int sn_network_add_odd_even_merger */
842 sn_network_t *sn_network_combine_bitonic_merge (sn_network_t *n0, /* {{{ */
845 sn_network_t *n0_clone;
847 int indizes_num = SN_NETWORK_INPUT_NUM (n0) + SN_NETWORK_INPUT_NUM (n1);
848 int indizes[indizes_num];
851 /* We need to invert n0, because the sequence must be
852 * z_1 >= z_2 >= ... >= z_k <= z_{k+1} <= ... <= z_p
853 * and NOT the other way around! Otherwise the comparators added in
854 * sn_network_add_bitonic_merger() from comparing (z_0,z_1), (z_2,z_3), ...
855 * to comparing ..., (z_{n-4},z_{n-3}), (z_{n-2},z_{n-1}), i.e. bound to the
856 * end of the list, possibly leaving z_0 uncompared. */
857 n0_clone = sn_network_clone (n0);
858 if (n0_clone == NULL)
860 sn_network_invert (n0_clone);
862 n = sn_network_concatenate (n0_clone, n1);
865 sn_network_destroy (n0_clone);
867 for (i = 0; i < indizes_num; i++)
870 sn_network_add_bitonic_merger (n, indizes, indizes_num);
873 } /* }}} sn_network_t *sn_network_combine_bitonic_merge */
875 sn_network_t *sn_network_combine_odd_even_merge (sn_network_t *n0, /* {{{ */
879 int indizes_left[n0->inputs_num];
880 int indizes_left_num;
881 int indizes_right[n1->inputs_num];
882 int indizes_right_num;
886 indizes_left_num = n0->inputs_num;
887 indizes_right_num = n1->inputs_num;
888 for (i = 0; i < indizes_left_num; i++)
890 for (i = 0; i < indizes_right_num; i++)
891 indizes_right[i] = indizes_left_num + i;
893 n = sn_network_concatenate (n0, n1);
897 status = sn_network_add_odd_even_merger (n,
898 indizes_left, indizes_left_num,
899 indizes_right, indizes_right_num);
902 sn_network_destroy (n);
906 sn_network_compress (n);
908 } /* }}} sn_network_t *sn_network_combine_odd_even_merge */
910 sn_network_t *sn_network_combine (sn_network_t *n0, /* {{{ */
913 return (sn_network_combine_odd_even_merge (n0, n1));
914 } /* }}} sn_network_t *sn_network_combine */
916 int sn_network_sort (sn_network_t *n, int *values) /* {{{ */
922 for (i = 0; i < n->stages_num; i++)
924 status = sn_stage_sort (n->stages[i], values);
930 } /* }}} int sn_network_sort */
932 int sn_network_brute_force_check (sn_network_t *n) /* {{{ */
934 int test_pattern[n->inputs_num];
935 int values[n->inputs_num];
939 memset (test_pattern, 0, sizeof (test_pattern));
945 /* Copy the current pattern and let the network sort it */
946 memcpy (values, test_pattern, sizeof (values));
947 status = sn_network_sort (n, values);
951 /* Check if the array is now sorted. */
952 previous = values[0];
953 for (i = 1; i < n->inputs_num; i++)
955 if (previous > values[i])
957 previous = values[i];
960 /* Generate the next test pattern */
962 for (i = 0; i < n->inputs_num; i++)
964 if (test_pattern[i] == 0)
977 /* Break out of the while loop if we tested all possible patterns */
982 /* All tests successfull */
984 } /* }}} int sn_network_brute_force_check */
986 sn_network_t *sn_network_read (FILE *fh) /* {{{ */
993 while (fgets (buffer, sizeof (buffer), fh) != NULL)
995 char *str_key = buffer;
996 char *str_value = NULL;
997 int buffer_len = strlen (buffer);
999 while ((buffer_len > 0) && ((buffer[buffer_len - 1] == '\n')
1000 || (buffer[buffer_len - 1] == '\r')))
1003 buffer[buffer_len] = '\0';
1005 if (buffer_len == 0)
1008 str_value = strchr (buffer, ':');
1009 if (str_value == NULL)
1011 printf ("Cannot parse line: %s\n", buffer);
1015 *str_value = '\0'; str_value++;
1016 while ((*str_value != '\0') && (isspace (*str_value) != 0))
1019 if (strcasecmp ("Inputs", str_key) == 0)
1020 opt_inputs = atoi (str_value);
1022 printf ("Unknown key: %s\n", str_key);
1023 } /* while (fgets) */
1028 n = sn_network_create (opt_inputs);
1034 s = sn_stage_read (fh);
1038 sn_network_stage_add (n, s);
1041 if (SN_NETWORK_STAGE_NUM (n) < 1)
1043 sn_network_destroy (n);
1048 } /* }}} sn_network_t *sn_network_read */
1050 sn_network_t *sn_network_read_file (const char *file) /* {{{ */
1055 fh = fopen (file, "r");
1059 n = sn_network_read (fh);
1064 } /* }}} sn_network_t *sn_network_read_file */
1066 int sn_network_write (sn_network_t *n, FILE *fh) /* {{{ */
1070 fprintf (fh, "Inputs: %i\n", n->inputs_num);
1073 for (i = 0; i < n->stages_num; i++)
1074 sn_stage_write (n->stages[i], fh);
1077 } /* }}} int sn_network_write */
1079 int sn_network_write_file (sn_network_t *n, const char *file) /* {{{ */
1084 fh = fopen (file, "w");
1088 status = sn_network_write (n, fh);
1093 } /* }}} int sn_network_write_file */
1095 int sn_network_serialize (sn_network_t *n, char **ret_buffer, /* {{{ */
1096 size_t *ret_buffer_size)
1103 buffer = *ret_buffer;
1104 buffer_size = *ret_buffer_size;
1106 #define SNPRINTF_OR_FAIL(...) \
1107 status = snprintf (buffer, buffer_size, __VA_ARGS__); \
1108 if ((status < 1) || (((size_t) status) >= buffer_size)) \
1111 buffer_size -= status;
1113 SNPRINTF_OR_FAIL ("Inputs: %i\r\n\r\n", n->inputs_num);
1115 for (i = 0; i < n->stages_num; i++)
1117 status = sn_stage_serialize (n->stages[i], &buffer, &buffer_size);
1122 *ret_buffer = buffer;
1123 *ret_buffer_size = buffer_size;
1125 } /* }}} int sn_network_serialize */
1127 sn_network_t *sn_network_unserialize (char *buffer, /* {{{ */
1133 if (buffer_size == 0)
1136 /* Read options first */
1137 while (buffer_size > 0)
1146 endptr = strchr (buffer, '\n');
1153 line_len = strlen (line);
1155 if ((line_len > 0) && (line[line_len - 1] == '\r'))
1157 line[line_len - 1] = 0;
1165 str_value = strchr (line, ':');
1166 if (str_value == NULL)
1168 printf ("Cannot parse line: %s\n", line);
1172 *str_value = '\0'; str_value++;
1173 while ((*str_value != '\0') && (isspace (*str_value) != 0))
1176 if (strcasecmp ("Inputs", str_key) == 0)
1177 opt_inputs = atoi (str_value);
1179 printf ("Unknown key: %s\n", str_key);
1180 } /* while (fgets) */
1185 n = sn_network_create (opt_inputs);
1191 s = sn_stage_unserialize (&buffer, &buffer_size);
1195 sn_network_stage_add (n, s);
1198 if (SN_NETWORK_STAGE_NUM (n) < 1)
1200 sn_network_destroy (n);
1205 } /* }}} sn_network_t *sn_network_unserialize */
1207 int sn_network_compare (const sn_network_t *n0, const sn_network_t *n1) /* {{{ */
1214 else if (n0 == NULL)
1216 else if (n1 == NULL)
1219 if (n0->inputs_num < n1->inputs_num)
1221 else if (n0->inputs_num > n1->inputs_num)
1224 if (n0->stages_num < n1->stages_num)
1226 else if (n0->stages_num > n1->stages_num)
1229 for (i = 0; i < n0->stages_num; i++)
1231 status = sn_stage_compare (n0->stages[i], n1->stages[i]);
1237 } /* }}} int sn_network_compare */
1239 uint64_t sn_network_get_hashval (const sn_network_t *n) /* {{{ */
1247 hash = (uint64_t) n->inputs_num;
1249 for (i = 0; i < n->stages_num; i++)
1250 hash = (hash * 104207) + sn_stage_get_hashval (n->stages[i]);
1253 } /* }}} uint64_t sn_network_get_hashval */
1255 /* vim: set sw=2 sts=2 et fdm=marker : */