source: CIVL/examples/mpi-omp/AMG2013/utilities/hypre_qsort.c

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 9.3 KB
Line 
1/*BHEADER**********************************************************************
2 * Copyright (c) 2008, Lawrence Livermore National Security, LLC.
3 * Produced at the Lawrence Livermore National Laboratory.
4 * This file is part of HYPRE. See file COPYRIGHT for details.
5 *
6 * HYPRE is free software; you can redistribute it and/or modify it under the
7 * terms of the GNU Lesser General Public License (as published by the Free
8 * Software Foundation) version 2.1 dated February 1999.
9 *
10 * $Revision: 2.4 $
11 ***********************************************************************EHEADER*/
12
13#include "HYPRE.h"
14
15/*--------------------------------------------------------------------------
16 *--------------------------------------------------------------------------*/
17
18void swap( int *v,
19 int i,
20 int j )
21{
22 int temp;
23
24 temp = v[i];
25 v[i] = v[j];
26 v[j] = temp;
27}
28
29/*--------------------------------------------------------------------------
30 *--------------------------------------------------------------------------*/
31
32void swap2(int *v,
33 double *w,
34 int i,
35 int j )
36{
37 int temp;
38 double temp2;
39
40 temp = v[i];
41 v[i] = v[j];
42 v[j] = temp;
43 temp2 = w[i];
44 w[i] = w[j];
45 w[j] = temp2;
46}
47
48/*--------------------------------------------------------------------------
49 *--------------------------------------------------------------------------*/
50
51void hypre_swap2i(int *v,
52 int *w,
53 int i,
54 int j )
55{
56 int temp;
57
58 temp = v[i];
59 v[i] = v[j];
60 v[j] = temp;
61 temp = w[i];
62 w[i] = w[j];
63 w[j] = temp;
64}
65
66
67/*--------------------------------------------------------------------------
68 *--------------------------------------------------------------------------*/
69
70
71/* AB 11/04 */
72
73void hypre_swap3i(int *v,
74 int *w,
75 int *z,
76 int i,
77 int j )
78{
79 int temp;
80
81 temp = v[i];
82 v[i] = v[j];
83 v[j] = temp;
84 temp = w[i];
85 w[i] = w[j];
86 w[j] = temp;
87 temp = z[i];
88 z[i] = z[j];
89 z[j] = temp;
90}
91
92
93/*--------------------------------------------------------------------------
94 *--------------------------------------------------------------------------*/
95
96void qsort0( int *v,
97 int left,
98 int right )
99{
100 int i, last;
101
102 if (left >= right)
103 return;
104 swap( v, left, (left+right)/2);
105 last = left;
106 for (i = left+1; i <= right; i++)
107 if (v[i] < v[left])
108 {
109 swap(v, ++last, i);
110 }
111 swap(v, left, last);
112 qsort0(v, left, last-1);
113 qsort0(v, last+1, right);
114}
115
116/*--------------------------------------------------------------------------
117 *--------------------------------------------------------------------------*/
118
119void qsort1( int *v,
120 double *w,
121 int left,
122 int right )
123{
124 int i, last;
125
126 if (left >= right)
127 return;
128 swap2( v, w, left, (left+right)/2);
129 last = left;
130 for (i = left+1; i <= right; i++)
131 if (v[i] < v[left])
132 {
133 swap2(v, w, ++last, i);
134 }
135 swap2(v, w, left, last);
136 qsort1(v, w, left, last-1);
137 qsort1(v, w, last+1, right);
138}
139
140/*--------------------------------------------------------------------------
141 *--------------------------------------------------------------------------*/
142
143void hypre_qsort2i( int *v,
144 int *w,
145 int left,
146 int right )
147{
148 int i, last;
149
150 if (left >= right)
151 {
152 return;
153 }
154 hypre_swap2i( v, w, left, (left+right)/2);
155 last = left;
156 for (i = left+1; i <= right; i++)
157 {
158 if (v[i] < v[left])
159 {
160 hypre_swap2i(v, w, ++last, i);
161 }
162 }
163 hypre_swap2i(v, w, left, last);
164 hypre_qsort2i(v, w, left, last-1);
165 hypre_qsort2i(v, w, last+1, right);
166}
167
168/*--------------------------------------------------------------------------
169 *--------------------------------------------------------------------------*/
170
171/* sort on w (double), move v (AB 11/04) */
172
173
174void hypre_qsort2( int *v,
175 double *w,
176 int left,
177 int right )
178{
179 int i, last;
180
181 if (left >= right)
182 return;
183 swap2( v, w, left, (left+right)/2);
184 last = left;
185 for (i = left+1; i <= right; i++)
186 if (w[i] < w[left])
187 {
188 swap2(v, w, ++last, i);
189 }
190 swap2(v, w, left, last);
191 hypre_qsort2(v, w, left, last-1);
192 hypre_qsort2(v, w, last+1, right);
193}
194
195/*--------------------------------------------------------------------------
196 *--------------------------------------------------------------------------*/
197
198/* sort on v, move w and z (AB 11/04) */
199
200void hypre_qsort3i( int *v,
201 int *w,
202 int *z,
203 int left,
204 int right )
205{
206 int i, last;
207
208 if (left >= right)
209 {
210 return;
211 }
212 hypre_swap3i( v, w, z, left, (left+right)/2);
213 last = left;
214 for (i = left+1; i <= right; i++)
215 {
216 if (v[i] < v[left])
217 {
218 hypre_swap3i(v, w, z, ++last, i);
219 }
220 }
221 hypre_swap3i(v, w, z, left, last);
222 hypre_qsort3i(v, w, z, left, last-1);
223 hypre_qsort3i(v, w, z, last+1, right);
224}
225
226/*--------------------------------------------------------------------------
227 *--------------------------------------------------------------------------*/
228
229void hypre_BigSwapbi(HYPRE_BigInt *v,
230 int *w,
231 int i,
232 int j )
233{
234 HYPRE_BigInt big_temp;
235 int temp;
236
237 big_temp = v[i];
238 v[i] = v[j];
239 v[j] = big_temp;
240 temp = w[i];
241 w[i] = w[j];
242 w[j] = temp;
243}
244
245/*--------------------------------------------------------------------------
246 *--------------------------------------------------------------------------*/
247
248void hypre_BigQsortbi( HYPRE_BigInt *v,
249 int *w,
250 int left,
251 int right )
252{
253 int i, last;
254
255 if (left >= right)
256 {
257 return;
258 }
259 hypre_BigSwapbi( v, w, left, (left+right)/2);
260 last = left;
261 for (i = left+1; i <= right; i++)
262 {
263 if (v[i] < v[left])
264 {
265 hypre_BigSwapbi(v, w, ++last, i);
266 }
267 }
268 hypre_BigSwapbi(v, w, left, last);
269 hypre_BigQsortbi(v, w, left, last-1);
270 hypre_BigQsortbi(v, w, last+1, right);
271}
272
273/*--------------------------------------------------------------------------
274 *--------------------------------------------------------------------------*/
275
276void hypre_BigSwapLoc(HYPRE_BigInt *v,
277 int *w,
278 int i,
279 int j )
280{
281 HYPRE_BigInt big_temp;
282
283 big_temp = v[i];
284 v[i] = v[j];
285 v[j] = big_temp;
286 w[i] = j;
287 w[j] = i;
288}
289
290/*--------------------------------------------------------------------------
291 *--------------------------------------------------------------------------*/
292
293void hypre_BigQsortbLoc( HYPRE_BigInt *v,
294 int *w,
295 int left,
296 int right )
297{
298 int i, last;
299
300 if (left >= right)
301 {
302 return;
303 }
304 hypre_BigSwapLoc( v, w, left, (left+right)/2);
305 last = left;
306 for (i = left+1; i <= right; i++)
307 {
308 if (v[i] < v[left])
309 {
310 hypre_BigSwapLoc(v, w, ++last, i);
311 }
312 }
313 hypre_BigSwapLoc(v, w, left, last);
314 hypre_BigQsortbLoc(v, w, left, last-1);
315 hypre_BigQsortbLoc(v, w, last+1, right);
316}
317
318/*--------------------------------------------------------------------------
319 *--------------------------------------------------------------------------*/
320
321
322void hypre_BigSwapb2i(HYPRE_BigInt *v,
323 int *w,
324 int *z,
325 int i,
326 int j )
327{
328 HYPRE_BigInt big_temp;
329 int temp;
330
331 big_temp = v[i];
332 v[i] = v[j];
333 v[j] = big_temp;
334 temp = w[i];
335 w[i] = w[j];
336 w[j] = temp;
337 temp = z[i];
338 z[i] = z[j];
339 z[j] = temp;
340}
341
342/*--------------------------------------------------------------------------
343 *--------------------------------------------------------------------------*/
344
345void hypre_BigQsortb2i( HYPRE_BigInt *v,
346 int *w,
347 int *z,
348 int left,
349 int right )
350{
351 int i, last;
352
353 if (left >= right)
354 {
355 return;
356 }
357 hypre_BigSwapb2i( v, w, z, left, (left+right)/2);
358 last = left;
359 for (i = left+1; i <= right; i++)
360 {
361 if (v[i] < v[left])
362 {
363 hypre_BigSwapb2i(v, w, z, ++last, i);
364 }
365 }
366 hypre_BigSwapb2i(v, w, z, left, last);
367 hypre_BigQsortb2i(v, w, z, left, last-1);
368 hypre_BigQsortb2i(v, w, z, last+1, right);
369}
370
371/*--------------------------------------------------------------------------
372 *--------------------------------------------------------------------------*/
373void hypre_BigSwap( HYPRE_BigInt *v,
374 int i,
375 int j )
376{
377 HYPRE_BigInt temp;
378
379 temp = v[i];
380 v[i] = v[j];
381 v[j] = temp;
382}
383
384/*--------------------------------------------------------------------------
385 *--------------------------------------------------------------------------*/
386
387void hypre_BigQsort0( HYPRE_BigInt *v,
388 int left,
389 int right )
390{
391 int i, last;
392
393 if (left >= right)
394 return;
395 hypre_BigSwap( v, left, (left+right)/2);
396 last = left;
397 for (i = left+1; i <= right; i++)
398 if (v[i] < v[left])
399 {
400 hypre_BigSwap(v, ++last, i);
401 }
402 hypre_BigSwap(v, left, last);
403 hypre_BigQsort0(v, left, last-1);
404 hypre_BigQsort0(v, last+1, right);
405}
406
Note: See TracBrowser for help on using the repository browser.