| /* |
| * Copyright (c) 2011-2012, Los Alamos National Security, LLC. |
| * All rights Reserved. |
| * |
| * Copyright 2011-2012. Los Alamos National Security, LLC. This software was produced |
| * under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National |
| * Laboratory (LANL), which is operated by Los Alamos National Security, LLC |
| * for the U.S. Department of Energy. The U.S. Government has rights to use, |
| * reproduce, and distribute this software. NEITHER THE GOVERNMENT NOR LOS |
| * ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR |
| * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified |
| * to produce derivative works, such modified software should be clearly marked, |
| * so as not to confuse it with the version available from LANL. |
| * |
| * Additionally, redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * * Neither the name of the Los Alamos National Security, LLC, Los Alamos |
| * National Laboratory, LANL, the U.S. Government, nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE LOS ALAMOS NATIONAL SECURITY, LLC AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT |
| * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL LOS ALAMOS NATIONAL |
| * SECURITY, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| * |
| * CLAMR -- LA-CC-11-094 |
| * This research code is being developed as part of the |
| * 2011 X Division Summer Workshop for the express purpose |
| * of a collaborative code for development of ideas in |
| * the implementation of AMR codes for Exascale platforms |
| * |
| * AMR implementation of the Wave code previously developed |
| * as a demonstration code for regular grids on Exascale platforms |
| * as part of the Supercomputing Challenge and Los Alamos |
| * National Laboratory |
| * |
| * Authors: Bob Robey XCP-2 brobey@lanl.gov |
| * Neal Davis davis68@lanl.gov, davis68@illinois.edu |
| * David Nicholaeff dnic@lanl.gov, mtrxknight@aol.com |
| * Dennis Trujillo dptrujillo@lanl.gov, dptru10@gmail.com |
| * |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "s7.h" |
| |
| void S7_Sort( |
| void * array_in, |
| const int nsize, |
| const enum S7_Datatype S7_datatype |
| ) |
| { |
| int n, child, parent, i; |
| |
| int qint; |
| long qlong; |
| long long qlonglong; |
| float qfloat; |
| double qdouble; |
| |
| int |
| *int_data_ptr; |
| long |
| *long_data_ptr; |
| long long |
| *longlong_data_ptr; |
| float |
| *float_data_ptr; |
| double |
| *double_data_ptr; |
| |
| // Heapsort |
| |
| i=nsize/2; |
| n = nsize; |
| |
| switch (S7_datatype){ |
| case S7_INTEGER4: |
| case S7_INT: |
| int_data_ptr = (int *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| qint=int_data_ptr[--i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| break; // End the sort here! |
| } // if n |
| qint=int_data_ptr[n]; |
| int_data_ptr[n]=int_data_ptr[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && int_data_ptr[child+1] > int_data_ptr[child]) child++; |
| if (int_data_ptr[child] > qint) { |
| int_data_ptr[parent] = int_data_ptr[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; // Break out of sift while loop |
| } // else |
| } // while |
| int_data_ptr[parent]=qint; |
| } // for |
| |
| break; |
| |
| case S7_LONG: |
| long_data_ptr = (long *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| qlong=long_data_ptr[--i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| break; // End the sort here! |
| } // if n |
| qlong=long_data_ptr[n]; |
| long_data_ptr[n]=long_data_ptr[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && long_data_ptr[child+1] > long_data_ptr[child]) child++; |
| if (long_data_ptr[child] > qlong) { |
| long_data_ptr[parent] = long_data_ptr[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; // Break out of sift while loop |
| } // else |
| } // while |
| long_data_ptr[parent]=qlong; |
| } // for |
| |
| break; |
| |
| case S7_LONG_LONG_INT: |
| case S7_INTEGER8: |
| longlong_data_ptr = (long long *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| qlonglong=longlong_data_ptr[--i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| break; // End the sort here! |
| } // if n |
| qlonglong=longlong_data_ptr[n]; |
| longlong_data_ptr[n]=longlong_data_ptr[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && longlong_data_ptr[child+1] > longlong_data_ptr[child]) child++; |
| if (longlong_data_ptr[child] > qlonglong) { |
| longlong_data_ptr[parent] = longlong_data_ptr[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; // Break out of sift while loop |
| } // else |
| } // while |
| longlong_data_ptr[parent]=qlonglong; |
| } // for |
| |
| break; |
| |
| case S7_FLOAT: |
| case S7_REAL4: |
| float_data_ptr = (float *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| qfloat=float_data_ptr[--i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| break; // End the sort here! |
| } // if n |
| qfloat=float_data_ptr[n]; |
| float_data_ptr[n]=float_data_ptr[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && float_data_ptr[child+1] > float_data_ptr[child]) child++; |
| if (float_data_ptr[child] > qfloat) { |
| float_data_ptr[parent] = float_data_ptr[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; // Break out of sift while loop |
| } // else |
| } // while |
| float_data_ptr[parent]=qfloat; |
| } // for |
| |
| break; |
| |
| case S7_DOUBLE: |
| case S7_REAL8: |
| double_data_ptr = (double *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| qdouble=double_data_ptr[--i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| break; // End the sort here! |
| } // if n |
| qdouble=double_data_ptr[n]; |
| double_data_ptr[n]=double_data_ptr[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && double_data_ptr[child+1] > double_data_ptr[child]) child++; |
| if (double_data_ptr[child] > qdouble) { |
| double_data_ptr[parent] = double_data_ptr[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; // Break out of sift while loop |
| } // else |
| } // while |
| double_data_ptr[parent]=qdouble; |
| } // for |
| |
| break; |
| |
| default: |
| printf("Error -- S7_Datatype not supported in S7_Sort\n"); |
| exit(1); |
| break; |
| |
| } |
| } |
| |
| |
| void S7_Sort_2Arrays( |
| void * array_in1, |
| void * array_in2, |
| const int nsize, |
| const enum S7_Datatype S7_datatype |
| ) |
| { |
| int n, child, parent, i; |
| |
| int qint1, qint2; |
| long qlong1, qlong2; |
| long long qlonglong1, qlonglong2; |
| float qfloat1, qfloat2; |
| double qdouble1, qdouble2; |
| |
| int |
| *int_data_ptr1, *int_data_ptr2; |
| long |
| *long_data_ptr1, *long_data_ptr2; |
| long long |
| *longlong_data_ptr1, *longlong_data_ptr2; |
| float |
| *float_data_ptr1, *float_data_ptr2; |
| double |
| *double_data_ptr1, *double_data_ptr2; |
| |
| // Heapsort |
| |
| i=nsize/2; |
| n = nsize; |
| |
| switch (S7_datatype){ |
| case S7_INTEGER4: |
| case S7_INT: |
| int_data_ptr1 = (int *)array_in1; |
| int_data_ptr2 = (int *)array_in2; |
| |
| for (;;) { |
| if (i > 0) { |
| qint1=int_data_ptr1[--i]; |
| qint2=int_data_ptr2[i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; // End of sort |
| } // if n |
| qint1=int_data_ptr1[n]; |
| qint2=int_data_ptr2[n]; |
| int_data_ptr1[n]=int_data_ptr1[0]; |
| int_data_ptr2[n]=int_data_ptr2[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && int_data_ptr1[child+1] > int_data_ptr1[child]) child++; |
| if (int_data_ptr1[child] > qint1) { |
| int_data_ptr1[parent] = int_data_ptr1[child]; |
| int_data_ptr2[parent] = int_data_ptr2[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| int_data_ptr1[parent]=qint1; |
| int_data_ptr2[parent]=qint2; |
| } // for |
| break; |
| |
| case S7_LONG: |
| long_data_ptr1 = (long *)array_in1; |
| long_data_ptr2 = (long *)array_in2; |
| |
| for (;;) { |
| if (i > 0) { |
| qlong1=long_data_ptr1[--i]; |
| qlong2=long_data_ptr2[i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; // End of sort |
| } // if n |
| qlong1=long_data_ptr1[n]; |
| qlong2=long_data_ptr2[n]; |
| long_data_ptr1[n]=long_data_ptr1[0]; |
| long_data_ptr2[n]=long_data_ptr2[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && long_data_ptr1[child+1] > long_data_ptr1[child]) child++; |
| if (long_data_ptr1[child] > qlong1) { |
| long_data_ptr1[parent] = long_data_ptr1[child]; |
| long_data_ptr2[parent] = long_data_ptr2[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| long_data_ptr1[parent]=qlong1; |
| long_data_ptr2[parent]=qlong2; |
| } // for |
| break; |
| |
| case S7_LONG_LONG_INT: |
| case S7_INTEGER8: |
| longlong_data_ptr1 = (long long *)array_in1; |
| longlong_data_ptr2 = (long long *)array_in2; |
| |
| for (;;) { |
| if (i > 0) { |
| qlonglong1=longlong_data_ptr1[--i]; |
| qlonglong2=longlong_data_ptr2[i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; // End of sort |
| } // if n |
| qlonglong1=longlong_data_ptr1[n]; |
| qlonglong2=longlong_data_ptr2[n]; |
| longlong_data_ptr1[n]=longlong_data_ptr1[0]; |
| longlong_data_ptr2[n]=longlong_data_ptr2[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && longlong_data_ptr1[child+1] > longlong_data_ptr1[child]) child++; |
| if (longlong_data_ptr1[child] > qlonglong1) { |
| longlong_data_ptr1[parent] = longlong_data_ptr1[child]; |
| longlong_data_ptr2[parent] = longlong_data_ptr2[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| longlong_data_ptr1[parent]=qlonglong1; |
| longlong_data_ptr2[parent]=qlonglong2; |
| } // for |
| break; |
| |
| case S7_FLOAT: |
| case S7_REAL4: |
| float_data_ptr1 = (float *)array_in1; |
| float_data_ptr2 = (float *)array_in2; |
| |
| for (;;) { |
| if (i > 0) { |
| qfloat1=float_data_ptr1[--i]; |
| qfloat2=float_data_ptr2[i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; // End of sort |
| } // if n |
| qfloat1=float_data_ptr1[n]; |
| qfloat2=float_data_ptr2[n]; |
| float_data_ptr1[n]=float_data_ptr1[0]; |
| float_data_ptr2[n]=float_data_ptr2[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && float_data_ptr1[child+1] > float_data_ptr1[child]) child++; |
| if (float_data_ptr1[child] > qfloat1) { |
| float_data_ptr1[parent] = float_data_ptr1[child]; |
| float_data_ptr2[parent] = float_data_ptr2[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| float_data_ptr1[parent]=qfloat1; |
| float_data_ptr2[parent]=qfloat2; |
| } // for |
| break; |
| |
| case S7_DOUBLE: |
| case S7_REAL8: |
| double_data_ptr1 = (double *)array_in1; |
| double_data_ptr2 = (double *)array_in2; |
| |
| for (;;) { |
| if (i > 0) { |
| qdouble1=double_data_ptr1[--i]; |
| qdouble2=double_data_ptr2[i]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; // End of sort |
| } // if n |
| qdouble1=double_data_ptr1[n]; |
| qdouble2=double_data_ptr2[n]; |
| double_data_ptr1[n]=double_data_ptr1[0]; |
| double_data_ptr2[n]=double_data_ptr2[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && double_data_ptr1[child+1] > double_data_ptr1[child]) child++; |
| if (double_data_ptr1[child] > qdouble1) { |
| double_data_ptr1[parent] = double_data_ptr1[child]; |
| double_data_ptr2[parent] = double_data_ptr2[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| double_data_ptr1[parent]=qdouble1; |
| double_data_ptr2[parent]=qdouble2; |
| } // for |
| break; |
| |
| default: |
| printf("Error -- S7_Datatype not supported in S7_Sort\n"); |
| exit(1); |
| break; |
| } |
| } |
| |
| |
| |
| |
| |
| void S7_Index_Sort( |
| void * array_in, |
| const int nsize, |
| const enum S7_Datatype S7_datatype, |
| int * index |
| ) |
| { |
| int n, j, child, parent, i; |
| int indext; |
| |
| int qint; |
| long qlong; |
| long long qlonglong; |
| float qfloat; |
| double qdouble; |
| |
| int |
| *int_data_ptr; |
| long |
| *long_data_ptr; |
| long long |
| *longlong_data_ptr; |
| float |
| *float_data_ptr; |
| double |
| *double_data_ptr; |
| |
| // Heapsort |
| |
| // Initialize array with consecutive integers |
| for (j=0; j<nsize; j++) index[j]=j; |
| |
| i=nsize/2; |
| n = nsize; |
| |
| switch (S7_datatype){ |
| case S7_INTEGER4: |
| case S7_INT: |
| int_data_ptr = (int *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qint=int_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qint=int_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && int_data_ptr[index[child+1]] > int_data_ptr[index[child]]) child++; |
| if (int_data_ptr[index[child]] > qint) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| case S7_LONG: |
| long_data_ptr = (long *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qlong=long_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qlong=long_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && long_data_ptr[index[child+1]] > long_data_ptr[index[child]]) child++; |
| if (long_data_ptr[index[child]] > qlong) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| case S7_LONG_LONG_INT: |
| case S7_INTEGER8: |
| longlong_data_ptr = (long long *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qlonglong=longlong_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qlonglong=longlong_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && longlong_data_ptr[index[child+1]] > longlong_data_ptr[index[child]]) child++; |
| if (longlong_data_ptr[index[child]] > qlonglong) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| case S7_FLOAT: |
| case S7_REAL4: |
| float_data_ptr = (float *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qfloat=float_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qfloat=float_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && float_data_ptr[index[child+1]] > float_data_ptr[index[child]]) child++; |
| if (float_data_ptr[index[child]] > qfloat) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| |
| case S7_DOUBLE: |
| case S7_REAL8: |
| double_data_ptr = (double *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qdouble=double_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qdouble=double_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && double_data_ptr[index[child+1]] > double_data_ptr[index[child]]) child++; |
| if (double_data_ptr[index[child]] > qdouble) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| default: |
| printf("Error -- S7_Datatype not supported in S7_Index_Sort\n"); |
| exit(1); |
| break; |
| |
| } |
| } |
| |
| void S7_Indexi8_Sort( |
| void * array_in, |
| const int nsize, |
| const enum S7_Datatype S7_datatype, |
| long * index |
| ) |
| { |
| int n, j, child, parent, i; |
| long indext; |
| |
| int qint; |
| long qlong; |
| long long qlonglong; |
| float qfloat; |
| double qdouble; |
| |
| int |
| *int_data_ptr; |
| long |
| *long_data_ptr; |
| long long |
| *longlong_data_ptr; |
| float |
| *float_data_ptr; |
| double |
| *double_data_ptr; |
| |
| // Heapsort |
| |
| // Initialize array with consecutive integers |
| for (j=0; j<nsize; j++) index[j]=j; |
| |
| i=nsize/2; |
| n = nsize; |
| |
| switch (S7_datatype){ |
| case S7_INTEGER4: |
| case S7_INT: |
| int_data_ptr = (int *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qint=int_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qint=int_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && int_data_ptr[index[child+1]] > int_data_ptr[index[child]]) child++; |
| if (int_data_ptr[index[child]] > qint) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| case S7_LONG: |
| long_data_ptr = (long *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qlong=long_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qlong=long_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && long_data_ptr[index[child+1]] > long_data_ptr[index[child]]) child++; |
| if (long_data_ptr[index[child]] > qlong) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| case S7_LONG_LONG_INT: |
| case S7_INTEGER8: |
| longlong_data_ptr = (long long *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qlonglong=longlong_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qlonglong=longlong_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && longlong_data_ptr[index[child+1]] > longlong_data_ptr[index[child]]) child++; |
| if (longlong_data_ptr[index[child]] > qlonglong) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| case S7_FLOAT: |
| case S7_REAL4: |
| float_data_ptr = (float *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qfloat=float_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qfloat=float_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && float_data_ptr[index[child+1]] > float_data_ptr[index[child]]) child++; |
| if (float_data_ptr[index[child]] > qfloat) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| |
| case S7_DOUBLE: |
| case S7_REAL8: |
| double_data_ptr = (double *)array_in; |
| |
| for (;;) { |
| if (i > 0) { |
| indext=index[--i]; |
| qdouble=double_data_ptr[indext]; |
| } // if i > 0 |
| else { |
| n--; |
| if (n == 0) { |
| |
| return; |
| } // if n |
| indext=index[n]; |
| qdouble=double_data_ptr[indext]; |
| index[n]=index[0]; |
| } // else |
| |
| parent=i; |
| child = i*2 + 1; |
| while (child < n) { |
| if (child +1 < n && double_data_ptr[index[child+1]] > double_data_ptr[index[child]]) child++; |
| if (double_data_ptr[index[child]] > qdouble) { |
| index[parent] = index[child]; |
| parent=child; |
| child = parent*2 + 1; |
| } // if q |
| else { |
| break; |
| } // else |
| } // while |
| index[parent]=indext; |
| } // for |
| break; |
| |
| default: |
| printf("Error -- S7_Datatype not supported in S7_Indexi8_Sort\n"); |
| exit(1); |
| break; |
| |
| } |
| } |
