FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_mesh_hash_sort.c
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <string.h>
9#include <assert.h>
10#include <errno.h>
11#include <math.h>
12
13#include "hecmw_msgno.h"
14#include "hecmw_malloc.h"
15#include "hecmw_error.h"
16
17#include "hecmw_part_define.h"
19
20#define EDGE_INC_FACTOR (1.2)
21
22#define TSUF_INC_FACTOR (1.1)
23
24#define QSUF_INC_FACTOR (1.1)
25
27 int key;
28
30};
31
32static long long int n_edge = 0;
33
34static int *__edge_node = NULL;
35
36static struct hecmw_mesh_hash_link **e_hash_tbl = NULL;
37
38static size_t e_hash_size;
39
40static size_t e_buf_size;
41
42static int n_tsuf = 0;
43
44static int *__tsuf_node = NULL;
45
46static struct hecmw_mesh_hash_link **t_hash_tbl = NULL;
47
48static size_t t_hash_size;
49
50static size_t t_buf_size;
51
52static int n_qsuf = 0;
53
54static int *__qsuf_node = NULL;
55
56static struct hecmw_mesh_hash_link **q_hash_tbl = NULL;
57
58static size_t q_hash_size;
59
60static size_t q_buf_size;
61
63 int *node1;
64
65 int *node2;
66};
67
69 int *node1;
70
71 int *node2;
72
73 int *node3;
74};
75
77 int *node1;
78
79 int *node2;
80
81 int *node3;
82
83 int *node4;
84};
85
86static struct hecmw_edge_node *edge_node = NULL;
87
88static struct hecmw_tsuf_node *tsuf_node = NULL;
89
90static struct hecmw_qsuf_node *qsuf_node = NULL;
91
92/*================================================================================================*/
93
94extern int HECMW_mesh_hsort_edge_init(int n_node, int n_elem) {
95 size_t size;
96 long long int i;
97
98 if (n_node <= 0) {
99 HECMW_set_error(HECMW_PART_E_INV_ARG, "n_node=%d", n_node);
100 goto error;
101 }
102 if (n_elem <= 0) {
103 HECMW_set_error(HECMW_PART_E_INV_ARG, "n_elem=%d", n_elem);
104 goto error;
105 }
106
107 if (n_node < 1000000 && n_elem < 1000000) {
108 e_hash_size = (n_node > n_elem) ? n_node : n_elem;
109 e_buf_size = (n_node > n_elem) ? 10 * n_node : 10 * n_elem;
110 } else {
111 e_hash_size = (n_node > n_elem) ? n_node : n_elem;
112 e_buf_size = (n_node > n_elem) ? n_node : n_elem;
113 }
114
115 edge_node =
116 (struct hecmw_edge_node *)HECMW_malloc(sizeof(struct hecmw_edge_node));
117 if (edge_node == NULL) {
118 HECMW_set_error(errno, "");
119 goto error;
120 } else {
121 edge_node->node1 = NULL;
122 edge_node->node2 = NULL;
123 }
124 edge_node->node1 = (int *)HECMW_malloc(sizeof(int) * e_buf_size);
125 if (edge_node->node1 == NULL) {
126 HECMW_set_error(errno, "");
127 goto error;
128 }
129 edge_node->node2 = (int *)HECMW_malloc(sizeof(int) * e_buf_size);
130 if (edge_node->node2 == NULL) {
131 HECMW_set_error(errno, "");
132 goto error;
133 }
134
135 size = sizeof(struct hecmw_mesh_hash_link *) * e_hash_size;
136 e_hash_tbl = (struct hecmw_mesh_hash_link **)HECMW_malloc(size);
137 if (e_hash_tbl == NULL) {
138 HECMW_set_error(errno, "");
139 goto error;
140 } else {
141 for (i = 0; i < e_hash_size; i++) {
142 e_hash_tbl[i] = NULL;
143 }
144 }
145
146 n_edge = 0;
147
148 return 0;
149
150error:
152
153 return -1;
154}
155
156extern int HECMW_mesh_hsort_tsuf_init(int n_node, int n_elem) {
157 size_t size;
158 long long int i;
159
160 if (n_node <= 0) {
161 HECMW_set_error(HECMW_PART_E_INV_ARG, "n_node=%d", n_node);
162 goto error;
163 }
164 if (n_elem <= 0) {
165 HECMW_set_error(HECMW_PART_E_INV_ARG, "n_elem=%d", n_elem);
166 goto error;
167 }
168
169 if (n_node < 1000000 && n_elem < 1000000) {
170 t_hash_size = (n_node > n_elem) ? n_node : n_elem;
171 t_buf_size = (n_node > n_elem) ? 4 * n_node : 4 * n_elem;
172 } else {
173 t_hash_size = (n_node > n_elem) ? n_node : n_elem;
174 t_buf_size = (n_node > n_elem) ? n_node : n_elem;
175 }
176
177 tsuf_node =
178 (struct hecmw_tsuf_node *)HECMW_malloc(sizeof(struct hecmw_tsuf_node));
179 if (tsuf_node == NULL) {
180 HECMW_set_error(errno, "");
181 goto error;
182 } else {
183 tsuf_node->node1 = NULL;
184 tsuf_node->node2 = NULL;
185 tsuf_node->node3 = NULL;
186 }
187 tsuf_node->node1 = (int *)HECMW_malloc(sizeof(int) * t_buf_size);
188 if (tsuf_node->node1 == NULL) {
189 HECMW_set_error(errno, "");
190 goto error;
191 }
192 tsuf_node->node2 = (int *)HECMW_malloc(sizeof(int) * t_buf_size);
193 if (tsuf_node->node2 == NULL) {
194 HECMW_set_error(errno, "");
195 goto error;
196 }
197 tsuf_node->node3 = (int *)HECMW_malloc(sizeof(int) * t_buf_size);
198 if (tsuf_node->node3 == NULL) {
199 HECMW_set_error(errno, "");
200 goto error;
201 }
202
203 size = sizeof(struct hecmw_mesh_hash_link *) * t_hash_size;
204 t_hash_tbl = (struct hecmw_mesh_hash_link **)HECMW_malloc(size);
205 if (t_hash_tbl == NULL) {
206 HECMW_set_error(errno, "");
207 goto error;
208 } else {
209 for (i = 0; i < t_hash_size; i++) {
210 t_hash_tbl[i] = NULL;
211 }
212 }
213
214 n_tsuf = 0;
215
216 return 0;
217
218error:
220
221 return -1;
222}
223
224extern int HECMW_mesh_hsort_qsuf_init(int n_node, int n_elem) {
225 size_t size;
226 long long int i;
227
228 if (n_node <= 0) {
229 HECMW_set_error(HECMW_PART_E_INV_ARG, "n_node=%d", n_node);
230 goto error;
231 }
232 if (n_elem <= 0) {
233 HECMW_set_error(HECMW_PART_E_INV_ARG, "n_elem=%d", n_elem);
234 goto error;
235 }
236
237 if (n_node < 1000000 && n_elem < 1000000) {
238 q_hash_size = (n_node > n_elem) ? n_node : n_elem;
239 q_buf_size = (n_node > n_elem) ? 5 * n_node : 5 * n_elem;
240 } else {
241 q_hash_size = (n_node > n_elem) ? n_node : n_elem;
242 q_buf_size = (n_node > n_elem) ? n_node : n_elem;
243 }
244
245 qsuf_node =
246 (struct hecmw_qsuf_node *)HECMW_malloc(sizeof(struct hecmw_qsuf_node));
247 if (qsuf_node == NULL) {
248 HECMW_set_error(errno, "");
249 goto error;
250 } else {
251 qsuf_node->node1 = NULL;
252 qsuf_node->node2 = NULL;
253 qsuf_node->node3 = NULL;
254 qsuf_node->node4 = NULL;
255 }
256 qsuf_node->node1 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
257 if (qsuf_node->node1 == NULL) {
258 HECMW_set_error(errno, "");
259 goto error;
260 }
261 qsuf_node->node2 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
262 if (qsuf_node->node2 == NULL) {
263 HECMW_set_error(errno, "");
264 goto error;
265 }
266 qsuf_node->node3 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
267 if (qsuf_node->node3 == NULL) {
268 HECMW_set_error(errno, "");
269 goto error;
270 }
271 qsuf_node->node4 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
272 if (qsuf_node->node4 == NULL) {
273 HECMW_set_error(errno, "");
274 goto error;
275 }
276
277 size = sizeof(struct hecmw_mesh_hash_link *) * q_hash_size;
278 q_hash_tbl = (struct hecmw_mesh_hash_link **)HECMW_malloc(size);
279 if (q_hash_tbl == NULL) {
280 HECMW_set_error(errno, "");
281 goto error;
282 } else {
283 for (i = 0; i < q_hash_size; i++) {
284 q_hash_tbl[i] = NULL;
285 }
286 }
287
288 n_qsuf = 0;
289
290 return 0;
291
292error:
294
295 return -1;
296}
297
298/*================================================================================================*/
299
301 size_t new_buf_size;
302
303 new_buf_size = (size_t)(e_buf_size * EDGE_INC_FACTOR);
304
305 edge_node->node1 =
306 (int *)HECMW_realloc(edge_node->node1, sizeof(int) * new_buf_size);
307 if (edge_node->node1 == NULL) {
308 HECMW_set_error(errno, "");
309 goto error;
310 }
311 edge_node->node2 =
312 (int *)HECMW_realloc(edge_node->node2, sizeof(int) * new_buf_size);
313 if (edge_node->node2 == NULL) {
314 HECMW_set_error(errno, "");
315 goto error;
316 }
317
318 e_buf_size = new_buf_size;
319
320 return 0;
321
322error:
324
325 return -1;
326}
327
329 size_t new_buf_size;
330
331 new_buf_size = (size_t)(t_buf_size * TSUF_INC_FACTOR);
332
333 tsuf_node->node1 =
334 (int *)HECMW_realloc(tsuf_node->node1, sizeof(int) * new_buf_size);
335 if (tsuf_node->node1 == NULL) {
336 HECMW_set_error(errno, "");
337 goto error;
338 }
339 tsuf_node->node2 =
340 (int *)HECMW_realloc(tsuf_node->node2, sizeof(int) * new_buf_size);
341 if (tsuf_node->node2 == NULL) {
342 HECMW_set_error(errno, "");
343 goto error;
344 }
345 tsuf_node->node3 =
346 (int *)HECMW_realloc(tsuf_node->node3, sizeof(int) * new_buf_size);
347 if (tsuf_node->node3 == NULL) {
348 HECMW_set_error(errno, "");
349 goto error;
350 }
351
352 t_buf_size = new_buf_size;
353
354 return 0;
355
356error:
358
359 return -1;
360}
361
363 size_t new_buf_size;
364
365 new_buf_size = (size_t)(q_buf_size * QSUF_INC_FACTOR);
366
367 qsuf_node->node1 =
368 (int *)HECMW_realloc(qsuf_node->node1, sizeof(int) * new_buf_size);
369 if (qsuf_node->node1 == NULL) {
370 HECMW_set_error(errno, "");
371 goto error;
372 }
373 qsuf_node->node2 =
374 (int *)HECMW_realloc(qsuf_node->node2, sizeof(int) * new_buf_size);
375 if (qsuf_node->node2 == NULL) {
376 HECMW_set_error(errno, "");
377 goto error;
378 }
379 qsuf_node->node3 =
380 (int *)HECMW_realloc(qsuf_node->node3, sizeof(int) * new_buf_size);
381 if (qsuf_node->node3 == NULL) {
382 HECMW_set_error(errno, "");
383 goto error;
384 }
385 qsuf_node->node4 =
386 (int *)HECMW_realloc(qsuf_node->node4, sizeof(int) * new_buf_size);
387 if (qsuf_node->node4 == NULL) {
388 HECMW_set_error(errno, "");
389 goto error;
390 }
391
392 q_buf_size = new_buf_size;
393
394 return 0;
395
396error:
398
399 return -1;
400}
401
402/*================================================================================================*/
403
404extern long long int HECMW_mesh_hsort_edge_get_n(void) { return n_edge; }
405
406extern int HECMW_mesh_hsort_tsuf_get_n(void) { return n_tsuf; }
407
408extern int HECMW_mesh_hsort_qsuf_get_n(void) { return n_qsuf; }
409
410/*------------------------------------------------------------------------------------------------*/
411
413 long long int i;
414
415 __edge_node = (int *)HECMW_malloc(sizeof(int) * n_edge * 2);
416 if (__edge_node == NULL) {
417 HECMW_set_error(errno, "");
418 goto error;
419 }
420
421 for (i = 0; i < n_edge; i++) {
422 __edge_node[2 * i] = edge_node->node1[i];
423 __edge_node[2 * i + 1] = edge_node->node2[i];
424 }
425
426 return __edge_node;
427
428error:
429 HECMW_free(__edge_node);
430 __edge_node = NULL;
432
433 return NULL;
434}
435
437 int i;
438
439 __tsuf_node = (int *)HECMW_malloc(sizeof(int) * n_tsuf * 3);
440 if (__tsuf_node == NULL) {
441 HECMW_set_error(errno, "");
442 goto error;
443 }
444
445 for (i = 0; i < n_tsuf; i++) {
446 __tsuf_node[3 * i] = tsuf_node->node1[i];
447 __tsuf_node[3 * i + 1] = tsuf_node->node2[i];
448 __tsuf_node[3 * i + 2] = tsuf_node->node3[i];
449 }
450
451 return __tsuf_node;
452
453error:
454 HECMW_free(__tsuf_node);
455 __tsuf_node = NULL;
457
458 return NULL;
459}
460
462 int i;
463
464 __qsuf_node = (int *)HECMW_malloc(sizeof(int) * n_qsuf * 4);
465 if (__qsuf_node == NULL) {
466 HECMW_set_error(errno, "");
467 goto error;
468 }
469
470 for (i = 0; i < n_qsuf; i++) {
471 __qsuf_node[4 * i] = qsuf_node->node1[i];
472 __qsuf_node[4 * i + 1] = qsuf_node->node2[i];
473 __qsuf_node[4 * i + 2] = qsuf_node->node3[i];
474 __qsuf_node[4 * i + 3] = qsuf_node->node4[i];
475 }
476
477 return __qsuf_node;
478
479error:
480 HECMW_free(__qsuf_node);
482
483 return NULL;
484}
485
486/*================================================================================================*/
487
489 if (e_hash_tbl) {
490 long long int i;
491 struct hecmw_mesh_hash_link *p, *q;
492 for (i = 0; i < e_hash_size; i++) {
493 if (e_hash_tbl[i]) {
494 for (q = e_hash_tbl[i], p = e_hash_tbl[i]; p; p = q) {
495 q = q->next;
496 HECMW_free(p);
497 }
498 e_hash_tbl[i] = NULL;
499 }
500 }
501 HECMW_free(e_hash_tbl);
502 }
503 if (edge_node) {
504 HECMW_free(edge_node->node1);
505 HECMW_free(edge_node->node2);
506 }
507 HECMW_free(edge_node);
508
509 e_hash_tbl = NULL;
510 edge_node = NULL;
511}
512
514 if (t_hash_tbl) {
515 long long int i;
516 struct hecmw_mesh_hash_link *p, *q;
517 for (i = 0; i < t_hash_size; i++) {
518 if (t_hash_tbl[i]) {
519 for (q = t_hash_tbl[i], p = t_hash_tbl[i]; p; p = q) {
520 q = q->next;
521 HECMW_free(p);
522 }
523 t_hash_tbl[i] = NULL;
524 }
525 }
526 HECMW_free(t_hash_tbl);
527 }
528 if (tsuf_node) {
529 HECMW_free(tsuf_node->node1);
530 HECMW_free(tsuf_node->node2);
531 HECMW_free(tsuf_node->node3);
532 }
533 HECMW_free(tsuf_node);
534
535 t_hash_tbl = NULL;
536 tsuf_node = NULL;
537}
538
540 struct hecmw_mesh_hash_link *p, *q;
541 long long int i;
542
543 if (q_hash_tbl) {
544 for (i = 0; i < q_hash_size; i++) {
545 if (q_hash_tbl[i]) {
546 for (q = q_hash_tbl[i], p = q_hash_tbl[i]; p; p = q) {
547 q = q->next;
548 HECMW_free(p);
549 }
550 q_hash_tbl[i] = NULL;
551 }
552 }
553 HECMW_free(q_hash_tbl);
554 }
555 if (qsuf_node) {
556 HECMW_free(qsuf_node->node1);
557 HECMW_free(qsuf_node->node2);
558 HECMW_free(qsuf_node->node3);
559 HECMW_free(qsuf_node->node4);
560 }
561 HECMW_free(qsuf_node);
562
563 q_hash_tbl = NULL;
564 qsuf_node = NULL;
565}
566
567/*================================================================================================*/
568
569static void reorder_node_edge(int m1, int m2, int *n1, int *n2) {
570 if (m1 < m2) {
571 *n1 = m1;
572 *n2 = m2;
573 } else {
574 *n1 = m2;
575 *n2 = m1;
576 }
577}
578
579static void reorder_node_tsuf(int m1, int m2, int m3, int *n1, int *n2,
580 int *n3) {
581 int l1, l2, l3;
582
583 if (m1 < m2) {
584 l1 = m1;
585 l2 = m2;
586 } else {
587 l1 = m2;
588 l2 = m1;
589 }
590
591 if (m3 < l1) {
592 *n1 = m3;
593 l3 = l1;
594 } else {
595 *n1 = l1;
596 l3 = m3;
597 }
598
599 if (l2 < l3) {
600 *n2 = l2;
601 *n3 = l3;
602 } else {
603 *n2 = l3;
604 *n3 = l2;
605 }
606}
607
608static void reorder_node_qsuf(int m1, int m2, int m3, int m4, int *n1, int *n2,
609 int *n3, int *n4) {
610 int l1, l2, l3, l4, l5, l6;
611
612 if (m1 < m2) {
613 l1 = m1;
614 l2 = m2;
615 } else {
616 l1 = m2;
617 l2 = m1;
618 }
619
620 if (m3 < m4) {
621 l3 = m3;
622 l4 = m4;
623 } else {
624 l3 = m4;
625 l4 = m3;
626 }
627
628 if (l1 < l3) {
629 *n1 = l1;
630 l5 = l3;
631 } else {
632 *n1 = l3;
633 l5 = l1;
634 }
635
636 if (l2 > l4) {
637 *n4 = l2;
638 l6 = l4;
639 } else {
640 *n4 = l4;
641 l6 = l2;
642 }
643
644 if (l5 < l6) {
645 *n2 = l5;
646 *n3 = l6;
647 } else {
648 *n2 = l6;
649 *n3 = l5;
650 }
651}
652
653/*================================================================================================*/
654
655extern long long int HECMW_mesh_hsort_edge(int node1, int node2) {
656 int n1, n2, m1, m2;
657 long long int eid;
658 int idx;
659 size_t ndot;
660 struct hecmw_mesh_hash_link *p;
661
662 reorder_node_edge(node1, node2, &n1, &n2);
663
664 ndot = ((size_t)n1 % e_hash_size) + ((size_t)n2 % e_hash_size);
665 idx = ndot % e_hash_size;
666
667 for (p = e_hash_tbl[idx]; p; p = p->next) {
668 eid = p->key;
669 reorder_node_edge(edge_node->node1[eid], edge_node->node2[eid], &m1, &m2);
670 if ((n1 == m1) && (n2 == m2)) {
671 return eid + 1;
672 }
673 }
674
676 sizeof(struct hecmw_mesh_hash_link));
677 if (p == NULL) {
678 HECMW_set_error(errno, "");
679 goto error;
680 }
681 p->next = e_hash_tbl[idx];
682 e_hash_tbl[idx] = p;
683
684 if (n_edge >= e_buf_size) {
686 goto error;
687 }
688 }
689
690 eid = n_edge;
691 p->key = eid;
692 edge_node->node1[eid] = node1;
693 edge_node->node2[eid] = node2;
694 n_edge++;
695
696 return eid + 1;
697
698error:
700
701 return -1;
702}
703
704extern int HECMW_mesh_hsort_tsuf(int node1, int node2, int node3) {
705 int n1, n2, n3, m1, m2, m3;
706 int tid;
707 long long int idx;
708 size_t ndot1, ndot;
709 struct hecmw_mesh_hash_link *p;
710
711 reorder_node_tsuf(node1, node2, node3, &n1, &n2, &n3);
712
713 ndot1 = ((size_t)n1 % t_hash_size) * ((size_t)n2 % t_hash_size);
714 ndot = ((size_t)n3 % t_hash_size) * (ndot1 % t_hash_size);
715 idx = ndot % t_hash_size;
716
717 for (p = t_hash_tbl[idx]; p; p = p->next) {
718 tid = p->key;
719 reorder_node_tsuf(tsuf_node->node1[tid], tsuf_node->node2[tid],
720 tsuf_node->node3[tid], &m1, &m2, &m3);
721 if ((n1 == m1) && (n2 == m2) && (n3 == m3)) {
722 return tid + 1;
723 }
724 }
725
727 sizeof(struct hecmw_mesh_hash_link));
728 if (p == NULL) {
729 HECMW_set_error(errno, "");
730 goto error;
731 }
732 p->next = t_hash_tbl[idx];
733 t_hash_tbl[idx] = p;
734
735 if (n_tsuf >= t_buf_size) {
737 goto error;
738 }
739 }
740
741 tid = n_tsuf;
742 p->key = tid;
743 p->next = NULL;
744 tsuf_node->node1[tid] = node1;
745 tsuf_node->node2[tid] = node2;
746 tsuf_node->node3[tid] = node3;
747 n_tsuf++;
748
749 return tid + 1;
750
751error:
753
754 return -1;
755}
756
757extern int HECMW_mesh_hsort_qsuf(int node1, int node2, int node3, int node4) {
758 int n1, n2, n3, n4, m1, m2, m3, m4;
759 int qid;
760 long long int idx;
761 size_t ndot1, ndot2, ndot;
762 struct hecmw_mesh_hash_link *p;
763
764 reorder_node_qsuf(node1, node2, node3, node4, &n1, &n2, &n3, &n4);
765
766 ndot1 = (n1 % q_hash_size) * (n2 % q_hash_size);
767 ndot2 = (n3 % q_hash_size) * (n4 % q_hash_size);
768 ndot = (ndot1 % q_hash_size) * (ndot2 % q_hash_size);
769 idx = ndot % q_hash_size;
770
771 for (p = q_hash_tbl[idx]; p; p = p->next) {
772 qid = p->key;
773 reorder_node_qsuf(qsuf_node->node1[qid], qsuf_node->node2[qid],
774 qsuf_node->node3[qid], qsuf_node->node4[qid], &m1, &m2,
775 &m3, &m4);
776
777 if ((n1 == m1) && (n2 == m2) && (n3 == m3) && (n4 == m4)) {
778 return qid + 1;
779 }
780 }
781
783 sizeof(struct hecmw_mesh_hash_link));
784 if (p == NULL) {
785 HECMW_set_error(errno, "");
786 goto error;
787 }
788 p->next = q_hash_tbl[idx];
789 q_hash_tbl[idx] = p;
790
791 if (n_qsuf >= q_buf_size) {
793 goto error;
794 }
795 }
796
797 qid = n_qsuf;
798 p->key = qid;
799 qsuf_node->node1[qid] = node1;
800 qsuf_node->node2[qid] = node2;
801 qsuf_node->node3[qid] = node3;
802 qsuf_node->node4[qid] = node3;
803 n_qsuf++;
804
805 return qid + 1;
806
807error:
809
810 return -1;
811}
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
#define NULL
#define HECMW_realloc(ptr, size)
Definition: hecmw_malloc.h:22
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
int HECMW_mesh_hsort_tsuf_realloc(void)
int HECMW_mesh_hsort_tsuf_init(int n_node, int n_elem)
int HECMW_mesh_hsort_qsuf(int node1, int node2, int node3, int node4)
#define TSUF_INC_FACTOR
int HECMW_mesh_hsort_tsuf_get_n(void)
int HECMW_mesh_hsort_tsuf(int node1, int node2, int node3)
int HECMW_mesh_hsort_qsuf_init(int n_node, int n_elem)
long long int HECMW_mesh_hsort_edge(int node1, int node2)
long long int HECMW_mesh_hsort_edge_get_n(void)
int * HECMW_mesh_hsort_tsuf_get_v(void)
int HECMW_mesh_hsort_edge_realloc(void)
int * HECMW_mesh_hsort_qsuf_get_v(void)
void HECMW_mesh_hsort_tsuf_final(void)
int HECMW_mesh_hsort_qsuf_get_n(void)
int * HECMW_mesh_hsort_edge_get_v(void)
void HECMW_mesh_hsort_qsuf_final(void)
void HECMW_mesh_hsort_edge_final(void)
int HECMW_mesh_hsort_edge_init(int n_node, int n_elem)
#define QSUF_INC_FACTOR
int HECMW_mesh_hsort_qsuf_realloc(void)
#define EDGE_INC_FACTOR
#define HECMW_PART_E_INV_ARG