Actual source code: sorti.c

petsc-main 2021-04-20
Report Typos and Errors
```
2: /*
3:    This file contains routines for sorting integers. Values are sorted in place.
4:    One can use src/sys/tests/ex52.c for benchmarking.
5:  */
6: #include <petsc/private/petscimpl.h>
7: #include <petsc/private/hashseti.h>

9: #define MEDIAN3(v,a,b,c)                                                        \
10:   (v[a]<v[b]                                                                    \
11:    ? (v[b]<v[c]                                                                 \
12:       ? (b)                                                                     \
13:       : (v[a]<v[c] ? (c) : (a)))                                                \
14:    : (v[c]<v[b]                                                                 \
15:       ? (b)                                                                     \
16:       : (v[a]<v[c] ? (a) : (c))))

18: #define MEDIAN(v,right) MEDIAN3(v,right/4,right/2,right/4*3)

20: /* Swap one, two or three pairs. Each pair can have its own type */
21: #define SWAP1(a,b,t1)               do {t1=a;a=b;b=t1;} while (0)
22: #define SWAP2(a,b,c,d,t1,t2)        do {t1=a;a=b;b=t1; t2=c;c=d;d=t2;} while (0)
23: #define SWAP3(a,b,c,d,e,f,t1,t2,t3) do {t1=a;a=b;b=t1; t2=c;c=d;d=t2; t3=e;e=f;f=t3;} while (0)

25: /* Swap a & b, *c & *d. c, d, t2 are pointers to a type of size <siz> */
26: #define SWAP2Data(a,b,c,d,t1,t2,siz)                                             \
27:   do {                                                                           \
29:     t1=a; a=b; b=t1;                                                             \
30:     PetscMemcpy(t2,c,siz);                                  \
31:     PetscMemcpy(c,d,siz);                                   \
32:     PetscMemcpy(d,t2,siz);                                  \
33:   } while (0)

35: /*
36:    Partition X[lo,hi] into two parts: X[lo,l) <= pivot; X[r,hi] > pivot

38:    Input Parameters:
39:     + X         - array to partition
40:     . pivot     - a pivot of X[]
41:     . t1        - temp variable for X
42:     - lo,hi     - lower and upper bound of the array

44:    Output Parameters:
45:     + l,r       - of type PetscInt

47:    Notes:
48:     The TwoWayPartition2/3 variants also partition other arrays along with X.
49:     These arrays can have different types, so they provide their own temp t2,t3
50:  */
51: #define TwoWayPartition1(X,pivot,t1,lo,hi,l,r)                                   \
52:   do {                                                                           \
53:     l = lo;                                                                      \
54:     r = hi;                                                                      \
55:     while (1) {                                                                   \
56:       while (X[l] < pivot) l++;                                                  \
57:       while (X[r] > pivot) r--;                                                  \
58:       if (l >= r) {r++; break;}                                                  \
59:       SWAP1(X[l],X[r],t1);                                                       \
60:       l++;                                                                       \
61:       r--;                                                                       \
62:     }                                                                            \
63:   } while (0)

65: /*
66:    Partition X[lo,hi] into two parts: X[lo,l) >= pivot; X[r,hi] < pivot

68:    Input Parameters:
69:     + X         - array to partition
70:     . pivot     - a pivot of X[]
71:     . t1        - temp variable for X
72:     - lo,hi     - lower and upper bound of the array

74:    Output Parameters:
75:     + l,r       - of type PetscInt

77:    Notes:
78:     The TwoWayPartition2/3 variants also partition other arrays along with X.
79:     These arrays can have different types, so they provide their own temp t2,t3
80:  */
81: #define TwoWayPartitionReverse1(X,pivot,t1,lo,hi,l,r)                                   \
82:   do {                                                                           \
83:     l = lo;                                                                      \
84:     r = hi;                                                                      \
85:     while (1) {                                                                   \
86:       while (X[l] > pivot) l++;                                                  \
87:       while (X[r] < pivot) r--;                                                  \
88:       if (l >= r) {r++; break;}                                                  \
89:       SWAP1(X[l],X[r],t1);                                                       \
90:       l++;                                                                       \
91:       r--;                                                                       \
92:     }                                                                            \
93:   } while (0)

95: #define TwoWayPartition2(X,Y,pivot,t1,t2,lo,hi,l,r)                              \
96:   do {                                                                           \
97:     l = lo;                                                                      \
98:     r = hi;                                                                      \
99:     while (1) {                                                                   \
100:       while (X[l] < pivot) l++;                                                  \
101:       while (X[r] > pivot) r--;                                                  \
102:       if (l >= r) {r++; break;}                                                  \
103:       SWAP2(X[l],X[r],Y[l],Y[r],t1,t2);                                          \
104:       l++;                                                                       \
105:       r--;                                                                       \
106:     }                                                                            \
107:   } while (0)

109: #define TwoWayPartition3(X,Y,Z,pivot,t1,t2,t3,lo,hi,l,r)                         \
110:   do {                                                                           \
111:     l = lo;                                                                      \
112:     r = hi;                                                                      \
113:     while (1) {                                                                   \
114:       while (X[l] < pivot) l++;                                                  \
115:       while (X[r] > pivot) r--;                                                  \
116:       if (l >= r) {r++; break;}                                                  \
117:       SWAP3(X[l],X[r],Y[l],Y[r],Z[l],Z[r],t1,t2,t3);                             \
118:       l++;                                                                       \
119:       r--;                                                                       \
120:     }                                                                            \
121:   } while (0)

123: /* Templates for similar functions used below */
124: #define QuickSort1(FuncName,X,n,pivot,t1,ierr)                                   \
125:   do {                                                                           \
126:     PetscInt i,j,p,l,r,hi=n-1;                                                   \
127:     if (n < 8) {                                                                 \
128:       for (i=0; i<n; i++) {                                                      \
129:         pivot = X[i];                                                            \
130:         for (j=i+1; j<n; j++) {                                                  \
131:           if (pivot > X[j]) {                                                    \
132:             SWAP1(X[i],X[j],t1);                                                 \
133:             pivot = X[i];                                                        \
134:           }                                                                      \
135:         }                                                                        \
136:       }                                                                          \
137:     } else {                                                                     \
138:       p     = MEDIAN(X,hi);                                                      \
139:       pivot = X[p];                                                              \
140:       TwoWayPartition1(X,pivot,t1,0,hi,l,r);                                     \
141:       FuncName(l,X);                                       \
142:       FuncName(hi-r+1,X+r);                                \
143:     }                                                                            \
144:   } while (0)

146: /* Templates for similar functions used below */
147: #define QuickSortReverse1(FuncName,X,n,pivot,t1,ierr)                            \
148:   do {                                                                           \
149:     PetscInt i,j,p,l,r,hi=n-1;                                                   \
150:     if (n < 8) {                                                                 \
151:       for (i=0; i<n; i++) {                                                      \
152:         pivot = X[i];                                                            \
153:         for (j=i+1; j<n; j++) {                                                  \
154:           if (pivot < X[j]) {                                                    \
155:             SWAP1(X[i],X[j],t1);                                                 \
156:             pivot = X[i];                                                        \
157:           }                                                                      \
158:         }                                                                        \
159:       }                                                                          \
160:     } else {                                                                     \
161:       p     = MEDIAN(X,hi);                                                      \
162:       pivot = X[p];                                                              \
163:       TwoWayPartitionReverse1(X,pivot,t1,0,hi,l,r);                              \
164:       FuncName(l,X);                                       \
165:       FuncName(hi-r+1,X+r);                                \
166:     }                                                                            \
167:   } while (0)

169: #define QuickSort2(FuncName,X,Y,n,pivot,t1,t2,ierr)                              \
170:   do {                                                                           \
171:     PetscInt i,j,p,l,r,hi=n-1;                                                   \
172:     if (n < 8) {                                                                 \
173:       for (i=0; i<n; i++) {                                                      \
174:         pivot = X[i];                                                            \
175:         for (j=i+1; j<n; j++) {                                                  \
176:           if (pivot > X[j]) {                                                    \
177:             SWAP2(X[i],X[j],Y[i],Y[j],t1,t2);                                    \
178:             pivot = X[i];                                                        \
179:           }                                                                      \
180:         }                                                                        \
181:       }                                                                          \
182:     } else {                                                                     \
183:       p     = MEDIAN(X,hi);                                                      \
184:       pivot = X[p];                                                              \
185:       TwoWayPartition2(X,Y,pivot,t1,t2,0,hi,l,r);                                \
186:       FuncName(l,X,Y);                                     \
187:       FuncName(hi-r+1,X+r,Y+r);                            \
188:     }                                                                            \
189:   } while (0)

191: #define QuickSort3(FuncName,X,Y,Z,n,pivot,t1,t2,t3,ierr)                         \
192:   do {                                                                           \
193:     PetscInt i,j,p,l,r,hi=n-1;                                                   \
194:     if (n < 8) {                                                                 \
195:       for (i=0; i<n; i++) {                                                      \
196:         pivot = X[i];                                                            \
197:         for (j=i+1; j<n; j++) {                                                  \
198:           if (pivot > X[j]) {                                                    \
199:             SWAP3(X[i],X[j],Y[i],Y[j],Z[i],Z[j],t1,t2,t3);                       \
200:             pivot = X[i];                                                        \
201:           }                                                                      \
202:         }                                                                        \
203:       }                                                                          \
204:     } else {                                                                     \
205:       p     = MEDIAN(X,hi);                                                      \
206:       pivot = X[p];                                                              \
207:       TwoWayPartition3(X,Y,Z,pivot,t1,t2,t3,0,hi,l,r);                           \
208:       FuncName(l,X,Y,Z);                                   \
209:       FuncName(hi-r+1,X+r,Y+r,Z+r);                        \
210:     }                                                                            \
211:   } while (0)

213: /*@
214:    PetscSortedInt - Determines whether the array is sorted.

216:    Not Collective

218:    Input Parameters:
219: +  n  - number of values
220: -  X  - array of integers

222:    Output Parameters:
223: .  sorted - flag whether the array is sorted

225:    Level: intermediate

227: .seealso: PetscSortInt(), PetscSortedMPIInt(), PetscSortedReal()
228: @*/
229: PetscErrorCode  PetscSortedInt(PetscInt n,const PetscInt X[],PetscBool *sorted)
230: {
232:   PetscSorted(n,X,*sorted);
233:   return(0);
234: }

236: /*@
237:    PetscSortInt - Sorts an array of integers in place in increasing order.

239:    Not Collective

241:    Input Parameters:
242: +  n  - number of values
243: -  X  - array of integers

245:    Notes:
246:    This function serves as an alternative to PetscIntSortSemiOrdered(), and may perform faster especially if the array
247:    is completely random. There are exceptions to this and so it is __highly__ recomended that the user benchmark their
248:    code to see which routine is fastest.

250:    Level: intermediate

252: .seealso: PetscIntSortSemiOrdered(), PetscSortReal(), PetscSortIntWithPermutation()
253: @*/
254: PetscErrorCode  PetscSortInt(PetscInt n,PetscInt X[])
255: {
257:   PetscInt       pivot,t1;

260:   QuickSort1(PetscSortInt,X,n,pivot,t1,ierr);
261:   return(0);
262: }

264: /*@
265:    PetscSortReverseInt - Sorts an array of integers in place in decreasing order.

267:    Not Collective

269:    Input Parameters:
270: +  n  - number of values
271: -  X  - array of integers

273:    Level: intermediate

275: .seealso: PetscIntSortSemiOrdered(), PetscSortInt(), PetscSortIntWithPermutation()
276: @*/
277: PetscErrorCode  PetscSortReverseInt(PetscInt n,PetscInt X[])
278: {
280:   PetscInt       pivot,t1;

283:   QuickSortReverse1(PetscSortReverseInt,X,n,pivot,t1,ierr);
284:   return(0);
285: }

287: /*@
288:    PetscSortedRemoveDupsInt - Removes all duplicate entries of a sorted input array

290:    Not Collective

292:    Input Parameters:
293: +  n  - number of values
294: -  X  - sorted array of integers

296:    Output Parameter:
297: .  n - number of non-redundant values

299:    Level: intermediate

301: .seealso: PetscSortInt()
302: @*/
303: PetscErrorCode  PetscSortedRemoveDupsInt(PetscInt *n,PetscInt X[])
304: {
305:   PetscInt i,s = 0,N = *n, b = 0;

309:   for (i=0; i<N-1; i++) {
310:     if (X[b+s+1] != X[b]) {
311:       X[b+1] = X[b+s+1]; b++;
312:     } else s++;
313:   }
314:   *n = N - s;
315:   return(0);
316: }

318: /*@
319:    PetscSortRemoveDupsInt - Sorts an array of integers in place in increasing order removes all duplicate entries

321:    Not Collective

323:    Input Parameters:
324: +  n  - number of values
325: -  X  - array of integers

327:    Output Parameter:
328: .  n - number of non-redundant values

330:    Level: intermediate

332: .seealso: PetscIntSortSemiOrdered(), PetscSortReal(), PetscSortIntWithPermutation(), PetscSortInt(), PetscSortedRemoveDupsInt()
333: @*/
334: PetscErrorCode  PetscSortRemoveDupsInt(PetscInt *n,PetscInt X[])
335: {

339:   PetscSortInt(*n,X);
340:   PetscSortedRemoveDupsInt(n,X);
341:   return(0);
342: }

344: /*@
345:   PetscFindInt - Finds integer in a sorted array of integers

347:    Not Collective

349:    Input Parameters:
350: +  key - the integer to locate
351: .  n   - number of values in the array
352: -  X  - array of integers

354:    Output Parameter:
355: .  loc - the location if found, otherwise -(slot+1) where slot is the place the value would go

357:    Level: intermediate

359: .seealso: PetscIntSortSemiOrdered(), PetscSortInt(), PetscSortIntWithArray(), PetscSortRemoveDupsInt()
360: @*/
361: PetscErrorCode PetscFindInt(PetscInt key, PetscInt n, const PetscInt X[], PetscInt *loc)
362: {
363:   PetscInt lo = 0,hi = n;

367:   if (!n) {*loc = -1; return(0);}
370:   while (hi - lo > 1) {
371:     PetscInt mid = lo + (hi - lo)/2;
372:     if (key < X[mid]) hi = mid;
373:     else               lo = mid;
374:   }
375:   *loc = key == X[lo] ? lo : -(lo + (key > X[lo]) + 1);
376:   return(0);
377: }

379: /*@

382:    Not Collective

384:    Input Parameters:
385: +  n  - number of values in the array
386: -  X  - array of integers

389:    Output Parameter:
390: .  dups - True if the array has dups, otherwise false

392:    Level: intermediate

394: .seealso: PetscSortRemoveDupsInt()
395: @*/
397: {
399:   PetscInt       i;
400:   PetscHSetI     ht;
401:   PetscBool      missing;

405:   *dups = PETSC_FALSE;
406:   if (n > 1) {
407:     PetscHSetICreate(&ht);
408:     PetscHSetIResize(ht,n);
409:     for (i=0; i<n; i++) {
411:       if (!missing) {*dups = PETSC_TRUE; break;}
412:     }
413:     PetscHSetIDestroy(&ht);
414:   }
415:   return(0);
416: }

418: /*@
419:   PetscFindMPIInt - Finds MPI integer in a sorted array of integers

421:    Not Collective

423:    Input Parameters:
424: +  key - the integer to locate
425: .  n   - number of values in the array
426: -  X   - array of integers

428:    Output Parameter:
429: .  loc - the location if found, otherwise -(slot+1) where slot is the place the value would go

431:    Level: intermediate

433: .seealso: PetscMPIIntSortSemiOrdered(), PetscSortInt(), PetscSortIntWithArray(), PetscSortRemoveDupsInt()
434: @*/
435: PetscErrorCode PetscFindMPIInt(PetscMPIInt key, PetscInt n, const PetscMPIInt X[], PetscInt *loc)
436: {
437:   PetscInt lo = 0,hi = n;

441:   if (!n) {*loc = -1; return(0);}
444:   while (hi - lo > 1) {
445:     PetscInt mid = lo + (hi - lo)/2;
446:     if (key < X[mid]) hi = mid;
447:     else               lo = mid;
448:   }
449:   *loc = key == X[lo] ? lo : -(lo + (key > X[lo]) + 1);
450:   return(0);
451: }

453: /*@
454:    PetscSortIntWithArray - Sorts an array of integers in place in increasing order;
455:        changes a second array to match the sorted first array.

457:    Not Collective

459:    Input Parameters:
460: +  n  - number of values
461: .  X  - array of integers
462: -  Y  - second array of integers

464:    Level: intermediate

466: .seealso: PetscIntSortSemiOrderedWithArray(), PetscSortReal(), PetscSortIntPermutation(), PetscSortInt()
467: @*/
468: PetscErrorCode  PetscSortIntWithArray(PetscInt n,PetscInt X[],PetscInt Y[])
469: {
471:   PetscInt       pivot,t1,t2;

474:   QuickSort2(PetscSortIntWithArray,X,Y,n,pivot,t1,t2,ierr);
475:   return(0);
476: }

478: /*@
479:    PetscSortIntWithArrayPair - Sorts an array of integers in place in increasing order;
480:        changes a pair of integer arrays to match the sorted first array.

482:    Not Collective

484:    Input Parameters:
485: +  n  - number of values
486: .  X  - array of integers
487: .  Y  - second array of integers (first array of the pair)
488: -  Z  - third array of integers  (second array of the pair)

490:    Level: intermediate

492: .seealso: PetscSortReal(), PetscSortIntPermutation(), PetscSortIntWithArray(), PetscIntSortSemiOrdered()
493: @*/
494: PetscErrorCode  PetscSortIntWithArrayPair(PetscInt n,PetscInt X[],PetscInt Y[],PetscInt Z[])
495: {
497:   PetscInt       pivot,t1,t2,t3;

500:   QuickSort3(PetscSortIntWithArrayPair,X,Y,Z,n,pivot,t1,t2,t3,ierr);
501:   return(0);
502: }

504: /*@
505:    PetscSortedMPIInt - Determines whether the array is sorted.

507:    Not Collective

509:    Input Parameters:
510: +  n  - number of values
511: -  X  - array of integers

513:    Output Parameters:
514: .  sorted - flag whether the array is sorted

516:    Level: intermediate

518: .seealso: PetscMPIIntSortSemiOrdered(), PetscSortMPIInt(), PetscSortedInt(), PetscSortedReal()
519: @*/
520: PetscErrorCode  PetscSortedMPIInt(PetscInt n,const PetscMPIInt X[],PetscBool *sorted)
521: {
523:   PetscSorted(n,X,*sorted);
524:   return(0);
525: }

527: /*@
528:    PetscSortMPIInt - Sorts an array of MPI integers in place in increasing order.

530:    Not Collective

532:    Input Parameters:
533: +  n  - number of values
534: -  X  - array of integers

536:    Level: intermediate

538:    Notes:
539:    This function serves as an alternative to PetscMPIIntSortSemiOrdered(), and may perform faster especially if the array
540:    is completely random. There are exceptions to this and so it is __highly__ recomended that the user benchmark their
541:    code to see which routine is fastest.

543: .seealso: PetscMPIIntSortSemiOrdered(), PetscSortReal(), PetscSortIntWithPermutation()
544: @*/
545: PetscErrorCode  PetscSortMPIInt(PetscInt n,PetscMPIInt X[])
546: {
548:   PetscMPIInt    pivot,t1;

551:   QuickSort1(PetscSortMPIInt,X,n,pivot,t1,ierr);
552:   return(0);
553: }

555: /*@
556:    PetscSortRemoveDupsMPIInt - Sorts an array of MPI integers in place in increasing order removes all duplicate entries

558:    Not Collective

560:    Input Parameters:
561: +  n  - number of values
562: -  X  - array of integers

564:    Output Parameter:
565: .  n - number of non-redundant values

567:    Level: intermediate

569: .seealso: PetscSortReal(), PetscSortIntWithPermutation(), PetscSortInt()
570: @*/
571: PetscErrorCode  PetscSortRemoveDupsMPIInt(PetscInt *n,PetscMPIInt X[])
572: {
574:   PetscInt       i,s = 0,N = *n, b = 0;

577:   PetscSortMPIInt(N,X);
578:   for (i=0; i<N-1; i++) {
579:     if (X[b+s+1] != X[b]) {
580:       X[b+1] = X[b+s+1]; b++;
581:     } else s++;
582:   }
583:   *n = N - s;
584:   return(0);
585: }

587: /*@
588:    PetscSortMPIIntWithArray - Sorts an array of integers in place in increasing order;
589:        changes a second array to match the sorted first array.

591:    Not Collective

593:    Input Parameters:
594: +  n  - number of values
595: .  X  - array of integers
596: -  Y  - second array of integers

598:    Level: intermediate

600: .seealso: PetscMPIIntSortSemiOrderedWithArray(), PetscSortReal(), PetscSortIntPermutation(), PetscSortInt()
601: @*/
602: PetscErrorCode  PetscSortMPIIntWithArray(PetscMPIInt n,PetscMPIInt X[],PetscMPIInt Y[])
603: {
605:   PetscMPIInt    pivot,t1,t2;

608:   QuickSort2(PetscSortMPIIntWithArray,X,Y,n,pivot,t1,t2,ierr);
609:   return(0);
610: }

612: /*@
613:    PetscSortMPIIntWithIntArray - Sorts an array of MPI integers in place in increasing order;
614:        changes a second array of Petsc intergers to match the sorted first array.

616:    Not Collective

618:    Input Parameters:
619: +  n  - number of values
620: .  X  - array of MPI integers
621: -  Y  - second array of Petsc integers

623:    Level: intermediate

625:    Notes: this routine is useful when one needs to sort MPI ranks with other integer arrays.

627: .seealso: PetscSortMPIIntWithArray(), PetscIntSortSemiOrderedWithArray(), PetscTimSortWithArray()
628: @*/
629: PetscErrorCode PetscSortMPIIntWithIntArray(PetscMPIInt n,PetscMPIInt X[],PetscInt Y[])
630: {
632:   PetscMPIInt    pivot,t1;
633:   PetscInt       t2;

636:   QuickSort2(PetscSortMPIIntWithIntArray,X,Y,n,pivot,t1,t2,ierr);
637:   return(0);
638: }

640: /*@
641:    PetscSortIntWithScalarArray - Sorts an array of integers in place in increasing order;
642:        changes a second SCALAR array to match the sorted first INTEGER array.

644:    Not Collective

646:    Input Parameters:
647: +  n  - number of values
648: .  X  - array of integers
649: -  Y  - second array of scalars

651:    Level: intermediate

653: .seealso: PetscTimSortWithArray(), PetscSortReal(), PetscSortIntPermutation(), PetscSortInt(), PetscSortIntWithArray()
654: @*/
655: PetscErrorCode  PetscSortIntWithScalarArray(PetscInt n,PetscInt X[],PetscScalar Y[])
656: {
658:   PetscInt       pivot,t1;
659:   PetscScalar    t2;

662:   QuickSort2(PetscSortIntWithScalarArray,X,Y,n,pivot,t1,t2,ierr);
663:   return(0);
664: }

666: /*@C
667:    PetscSortIntWithDataArray - Sorts an array of integers in place in increasing order;
668:        changes a second array to match the sorted first INTEGER array.  Unlike other sort routines, the user must
669:        provide workspace (the size of an element in the data array) to use when sorting.

671:    Not Collective

673:    Input Parameters:
674: +  n  - number of values
675: .  X  - array of integers
676: .  Y  - second array of data
677: .  size - sizeof elements in the data array in bytes
678: -  t2   - workspace of "size" bytes used when sorting

680:    Level: intermediate

682: .seealso: PetscTimSortWithArray(), PetscSortReal(), PetscSortIntPermutation(), PetscSortInt(), PetscSortIntWithArray()
683: @*/
684: PetscErrorCode  PetscSortIntWithDataArray(PetscInt n,PetscInt X[],void *Y,size_t size,void *t2)
685: {
687:   char           *YY = (char*)Y;
688:   PetscInt       i,j,p,t1,pivot,hi=n-1,l,r;

691:   if (n<8) {
692:     for (i=0; i<n; i++) {
693:       pivot = X[i];
694:       for (j=i+1; j<n; j++) {
695:         if (pivot > X[j]) {
696:           SWAP2Data(X[i],X[j],YY+size*i,YY+size*j,t1,t2,size);
697:           pivot = X[i];
698:         }
699:       }
700:     }
701:   } else {
702:     /* Two way partition */
703:     p     = MEDIAN(X,hi);
704:     pivot = X[p];
705:     l     = 0;
706:     r     = hi;
707:     while (1) {
708:       while (X[l] < pivot) l++;
709:       while (X[r] > pivot) r--;
710:       if (l >= r) {r++; break;}
711:       SWAP2Data(X[l],X[r],YY+size*l,YY+size*r,t1,t2,size);
712:       l++;
713:       r--;
714:     }
715:     PetscSortIntWithDataArray(l,X,Y,size,t2);
716:     PetscSortIntWithDataArray(hi-r+1,X+r,YY+size*r,size,t2);
717:   }
718:   return(0);
719: }

721: /*@
722:    PetscMergeIntArray -     Merges two SORTED integer arrays, removes duplicate elements.

724:    Not Collective

726:    Input Parameters:
727: +  an  - number of values in the first array
728: .  aI  - first sorted array of integers
729: .  bn  - number of values in the second array
730: -  bI  - second array of integers

732:    Output Parameters:
733: +  n   - number of values in the merged array
734: -  L   - merged sorted array, this is allocated if an array is not provided

736:    Level: intermediate

738: .seealso: PetscSortReal(), PetscSortIntPermutation(), PetscSortInt(), PetscSortIntWithArray()
739: @*/
740: PetscErrorCode  PetscMergeIntArray(PetscInt an,const PetscInt aI[], PetscInt bn, const PetscInt bI[], PetscInt *n, PetscInt **L)
741: {
743:   PetscInt       *L_ = *L, ak, bk, k;

745:   if (!L_) {
746:     PetscMalloc1(an+bn, L);
747:     L_   = *L;
748:   }
749:   k = ak = bk = 0;
750:   while (ak < an && bk < bn) {
751:     if (aI[ak] == bI[bk]) {
752:       L_[k] = aI[ak];
753:       ++ak;
754:       ++bk;
755:       ++k;
756:     } else if (aI[ak] < bI[bk]) {
757:       L_[k] = aI[ak];
758:       ++ak;
759:       ++k;
760:     } else {
761:       L_[k] = bI[bk];
762:       ++bk;
763:       ++k;
764:     }
765:   }
766:   if (ak < an) {
767:     PetscArraycpy(L_+k,aI+ak,an-ak);
768:     k   += (an-ak);
769:   }
770:   if (bk < bn) {
771:     PetscArraycpy(L_+k,bI+bk,bn-bk);
772:     k   += (bn-bk);
773:   }
774:   *n = k;
775:   return(0);
776: }

778: /*@
779:    PetscMergeIntArrayPair -     Merges two SORTED integer arrays that share NO common values along with an additional array of integers.
780:                                 The additional arrays are the same length as sorted arrays and are merged
781:                                 in the order determined by the merging of the sorted pair.

783:    Not Collective

785:    Input Parameters:
786: +  an  - number of values in the first array
787: .  aI  - first sorted array of integers
788: .  aJ  - first additional array of integers
789: .  bn  - number of values in the second array
790: .  bI  - second array of integers
791: -  bJ  - second additional of integers

793:    Output Parameters:
794: +  n   - number of values in the merged array (== an + bn)
795: .  L   - merged sorted array
796: -  J   - merged additional array

798:    Notes:
799:     if L or J point to non-null arrays then this routine will assume they are of the approproate size and use them, otherwise this routine will allocate space for them
800:    Level: intermediate

802: .seealso: PetscIntSortSemiOrdered(), PetscSortReal(), PetscSortIntPermutation(), PetscSortInt(), PetscSortIntWithArray()
803: @*/
804: PetscErrorCode  PetscMergeIntArrayPair(PetscInt an,const PetscInt aI[], const PetscInt aJ[], PetscInt bn, const PetscInt bI[], const PetscInt bJ[], PetscInt *n, PetscInt **L, PetscInt **J)
805: {
807:   PetscInt       n_, *L_, *J_, ak, bk, k;

812:   n_ = an + bn;
813:   *n = n_;
814:   if (!*L) {
815:     PetscMalloc1(n_, L);
816:   }
817:   L_ = *L;
818:   if (!*J) {
819:     PetscMalloc1(n_, J);
820:   }
821:   J_   = *J;
822:   k = ak = bk = 0;
823:   while (ak < an && bk < bn) {
824:     if (aI[ak] <= bI[bk]) {
825:       L_[k] = aI[ak];
826:       J_[k] = aJ[ak];
827:       ++ak;
828:       ++k;
829:     } else {
830:       L_[k] = bI[bk];
831:       J_[k] = bJ[bk];
832:       ++bk;
833:       ++k;
834:     }
835:   }
836:   if (ak < an) {
837:     PetscArraycpy(L_+k,aI+ak,an-ak);
838:     PetscArraycpy(J_+k,aJ+ak,an-ak);
839:     k   += (an-ak);
840:   }
841:   if (bk < bn) {
842:     PetscArraycpy(L_+k,bI+bk,bn-bk);
843:     PetscArraycpy(J_+k,bJ+bk,bn-bk);
844:   }
845:   return(0);
846: }

848: /*@
849:    PetscMergeMPIIntArray -     Merges two SORTED integer arrays.

851:    Not Collective

853:    Input Parameters:
854: +  an  - number of values in the first array
855: .  aI  - first sorted array of integers
856: .  bn  - number of values in the second array
857: -  bI  - second array of integers

859:    Output Parameters:
860: +  n   - number of values in the merged array (<= an + bn)
861: -  L   - merged sorted array, allocated if address of NULL pointer is passed

863:    Level: intermediate

865: .seealso: PetscIntSortSemiOrdered(), PetscSortReal(), PetscSortIntPermutation(), PetscSortInt(), PetscSortIntWithArray()
866: @*/
867: PetscErrorCode PetscMergeMPIIntArray(PetscInt an,const PetscMPIInt aI[],PetscInt bn,const PetscMPIInt bI[],PetscInt *n,PetscMPIInt **L)
868: {
870:   PetscInt       ai,bi,k;

873:   if (!*L) {PetscMalloc1((an+bn),L);}
874:   for (ai=0,bi=0,k=0; ai<an || bi<bn;) {
875:     PetscInt t = -1;
876:     for (; ai<an && (!bn || aI[ai] <= bI[bi]); ai++) (*L)[k++] = t = aI[ai];
877:     for (; bi<bn && bI[bi] == t; bi++);
878:     for (; bi<bn && (!an || bI[bi] <= aI[ai]); bi++) (*L)[k++] = t = bI[bi];
879:     for (; ai<an && aI[ai] == t; ai++);
880:   }
881:   *n = k;
882:   return(0);
883: }

885: /*@C
886:    PetscProcessTree - Prepares tree data to be displayed graphically

888:    Not Collective

890:    Input Parameters:
891: +  n  - number of values
892: .  mask - indicates those entries in the tree, location 0 is always masked
893: -  parentid - indicates the parent of each entry

895:    Output Parameters:
896: +  Nlevels - the number of levels
897: .  Level - for each node tells its level
898: .  Levelcnts - the number of nodes on each level
899: .  Idbylevel - a list of ids on each of the levels, first level followed by second etc
900: -  Column - for each id tells its column index

902:    Level: developer

904:    Notes:
905:     This code is not currently used

907: .seealso: PetscSortReal(), PetscSortIntWithPermutation()
908: @*/
909: PetscErrorCode  PetscProcessTree(PetscInt n,const PetscBool mask[],const PetscInt parentid[],PetscInt *Nlevels,PetscInt **Level,PetscInt **Levelcnt,PetscInt **Idbylevel,PetscInt **Column)
910: {
911:   PetscInt       i,j,cnt,nmask = 0,nlevels = 0,*level,*levelcnt,levelmax = 0,*workid,*workparentid,tcnt = 0,*idbylevel,*column;
913:   PetscBool      done = PETSC_FALSE;

917:   for (i=0; i<n; i++) {
919:     if (parentid[i]  == i) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Node labeled as own parent");
921:   }

923:   for (i=0; i<n; i++) {
925:   }

927:   /* determine the level in the tree of each node */
928:   PetscCalloc1(n,&level);

930:   level[0] = 1;
931:   while (!done) {
932:     done = PETSC_TRUE;
933:     for (i=0; i<n; i++) {
935:       if (!level[i] && level[parentid[i]]) level[i] = level[parentid[i]] + 1;
936:       else if (!level[i]) done = PETSC_FALSE;
937:     }
938:   }
939:   for (i=0; i<n; i++) {
940:     level[i]--;
941:     nlevels = PetscMax(nlevels,level[i]);
942:   }

944:   /* count the number of nodes on each level and its max */
945:   PetscCalloc1(nlevels,&levelcnt);
946:   for (i=0; i<n; i++) {
948:     levelcnt[level[i]-1]++;
949:   }
950:   for (i=0; i<nlevels;i++) levelmax = PetscMax(levelmax,levelcnt[i]);

952:   /* for each level sort the ids by the parent id */
953:   PetscMalloc2(levelmax,&workid,levelmax,&workparentid);
955:   for (j=1; j<=nlevels;j++) {
956:     cnt = 0;
957:     for (i=0; i<n; i++) {
959:       if (level[i] != j) continue;
960:       workid[cnt]         = i;
961:       workparentid[cnt++] = parentid[i];
962:     }
963:     /*  PetscIntView(cnt,workparentid,0);
964:     PetscIntView(cnt,workid,0);
965:     PetscSortIntWithArray(cnt,workparentid,workid);
966:     PetscIntView(cnt,workparentid,0);
967:     PetscIntView(cnt,workid,0);*/
968:     PetscArraycpy(idbylevel+tcnt,workid,cnt);
969:     tcnt += cnt;
970:   }
972:   PetscFree2(workid,workparentid);

974:   /* for each node list its column */
975:   PetscMalloc1(n,&column);
976:   cnt = 0;
977:   for (j=0; j<nlevels; j++) {
978:     for (i=0; i<levelcnt[j]; i++) {
979:       column[idbylevel[cnt++]] = i;
980:     }
981:   }

983:   *Nlevels   = nlevels;
984:   *Level     = level;
985:   *Levelcnt  = levelcnt;
986:   *Idbylevel = idbylevel;
987:   *Column    = column;
988:   return(0);
989: }

991: /*@
992:   PetscParallelSortedInt - Check whether an integer array, distributed over a communicator, is globally sorted.

994:   Collective

996:   Input Parameters:
997: + comm - the MPI communicator
998: . n - the local number of integers
999: - keys - the local array of integers

1001:   Output Parameters:
1002: . is_sorted - whether the array is globally sorted

1004:   Level: developer

1006: .seealso: PetscParallelSortInt()
1007: @*/
1008: PetscErrorCode PetscParallelSortedInt(MPI_Comm comm, PetscInt n, const PetscInt keys[], PetscBool *is_sorted)
1009: {
1010:   PetscBool      sorted;
1011:   PetscInt       i, min, max, prevmax;
1012:   PetscMPIInt    rank;

1016:   sorted = PETSC_TRUE;
1017:   min    = PETSC_MAX_INT;
1018:   max    = PETSC_MIN_INT;
1019:   if (n) {
1020:     min = keys[0];
1021:     max = keys[0];
1022:   }
1023:   for (i = 1; i < n; i++) {
1024:     if (keys[i] < keys[i - 1]) break;
1025:     min = PetscMin(min,keys[i]);
1026:     max = PetscMax(max,keys[i]);
1027:   }
1028:   if (i < n) sorted = PETSC_FALSE;
1029:   prevmax = PETSC_MIN_INT;
1030:   MPI_Exscan(&max, &prevmax, 1, MPIU_INT, MPI_MAX, comm);
1031:   MPI_Comm_rank(comm, &rank);
1032:   if (!rank) prevmax = PETSC_MIN_INT;
1033:   if (prevmax > min) sorted = PETSC_FALSE;
1034:   MPI_Allreduce(&sorted, is_sorted, 1, MPIU_BOOL, MPI_LAND, comm);
1035:   return(0);
1036: }
```