IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 16040


Ignore:
Timestamp:
Jan 8, 2008, 12:50:52 PM (18 years ago)
Author:
eugene
Message:

replaced sort functions drived from press with sort macros derived from gsl

Location:
trunk/Ohana/src
Files:
3 added
7 deleted
75 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/addstar/Makefile

    r15036 r16040  
    6868$(SRC)/ReadStarsTEXT.$(ARCH).o \
    6969$(SRC)/FilterStars.$(ARCH).o \
    70 $(SRC)/sort_lists.$(ARCH).o \
    7170$(SRC)/ImageOptions.$(ARCH).o \
    7271$(SRC)/GetFileMode.$(ARCH).o \
    … …  
    114113$(SRC)/opening_angle.$(ARCH).o \
    115114$(SRC)/replace_match.$(ARCH).o \
    116 $(SRC)/sort_lists.$(ARCH).o \
    117115$(SRC)/update_coords.$(ARCH).o
    118116
    … …  
    151149$(SRC)/SkyRegionUtils.$(ARCH).o \
    152150$(SRC)/SkyListForStars.$(ARCH).o \
    153 $(SRC)/sort_lists.$(ARCH).o \
    154151$(SRC)/update_coords.$(ARCH).o \
    155152$(SRC)/Shutdown.$(ARCH).o \
    … …  
    194191$(SRC)/find_matches_refstars.$(ARCH).o \
    195192$(SRC)/args_load2mass.$(ARCH).o \
    196 $(SRC)/sort_lists.$(ARCH).o \
    197193$(SRC)/replace_match.$(ARCH).o \
    198194$(SRC)/update_coords.$(ARCH).o \

  • trunk/Ohana/src/addstar/src/SEDops.c

    r13479 r16040  
    5757SEDtableRow **sort_SEDtable (SEDtableRow *raw, int N) {
    5858
    59   int l,j,ir,i;
    60   SEDtableRow **value, *temp;
     59  int i;
     60
     61  SEDtableRow **value;
    6162 
    6263  if (N <= 0) return (NULL);
    … …  
    6667    value[i] = &raw[i];
    6768  }
    68   if (N < 2) return (value);
    69 
    70   l = N >> 1;
    71   ir = N - 1;
    72   for (;;) {
    73     if (l > 0) {
    74       l--;
    75       temp = value[l];
    76     }
    77     else {
    78       temp = value[ir];
    79       value[ir] = value[0];
    80       if (--ir == 0) {
    81         value[0] = temp;
    82         return (value);
    83       }
    84     }
    85     i = l;
    86     j = (l << 1) + 1;
    87     while (j <= ir) {
    88       if (j < ir && value[j][0].color < value[j+1][0].color) ++j;
    89       if (temp[0].color < value[j][0].color) {
    90         value[i] = value[j];
    91         j += (i=j) + 1;
    92       }
    93       else j = ir + 1;
    94     }
    95     value[i] = temp;
    96   }
     69
     70# define SWAPFUNC(A,B){ SEDtableRow *temp = value[A]; value[A] = value[B]; value[B] = temp; }
     71# define COMPARE(A,B)(value[A][0].color < value[B][0].color)
     72
     73  OHANA_SORT (N, COMPARE, SWAPFUNC);
     74
     75# undef SWAPFUNC
     76# undef COMPARE
    9777
    9878  return (value);

  • trunk/Ohana/src/addstar/src/SkyListForStars.c

    r14401 r16040  
    1515  list[0].ownElements = FALSE; // free these elements when freeing the list
    1616
    17   sort_stars (stars, Nstars); /* sort by RA */
     17  sort_stars_ra (stars, Nstars); /* sort by RA */
    1818  for (i = 0; i < Nstars; i++) {
    1919    if (stars[i].found) continue;

  • trunk/Ohana/src/addstar/src/calibrate.c

    r15509 r16040  
    188188    return;
    189189  }
    190   fsort2 (Dmag, dDmag, Nkeep);
     190  fsortpair (Dmag, dDmag, Nkeep);
    191191
    192192  /* take sort list of Dmag, find median */

  • trunk/Ohana/src/addstar/src/find_matches.c

    r15743 r16040  
    55  int i, j, n, N, J, status, Nstars;
    66  double RADIUS, RADIUS2;
    7   float *X1, *Y1, *X2, *Y2;
    8   float dX, dY, dR;
     7  double *X1, *Y1, *X2, *Y2;
     8  double dX, dY, dR;
    99  int *N1, *N2,  *next_meas;
    1010  int Nave, NAVE, Nmeas, NMEAS, Nmatch;
    … …  
    2121
    2222  /** allocate local arrays (stars) **/
    23   ALLOCATE (X1, float, NstarsIn);
    24   ALLOCATE (Y1, float, NstarsIn);
     23  ALLOCATE (X1, double, NstarsIn);
     24  ALLOCATE (Y1, double, NstarsIn);
    2525  ALLOCATE (N1, int,   NstarsIn);
    2626
    2727  /** allocate local arrays (catalog) **/
    2828  NAVE = Nave = catalog[0].Naverage;
    29   ALLOCATE (X2, float, NAVE);
    30   ALLOCATE (Y2, float, NAVE);
     29  ALLOCATE (X2, double, NAVE);
     30  ALLOCATE (Y2, double, NAVE);
    3131  ALLOCATE (N2, int,   NAVE);
    3232  ALLOCATE (catalog[0].found, int, NAVE);
    … …  
    6060  Nstars = 0;
    6161  for (i = 0; i < NstarsIn; i++) {
    62     status = fRD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].R, stars[i].D, &tcoords);
     62    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].R, stars[i].D, &tcoords);
    6363    if (!status) continue;
    6464    N1[Nstars] = i;
    … …  
    7676    return (0);
    7777  }
    78   if (Nstars > 1) sort_lists (X1, Y1, N1, Nstars);
     78  if (Nstars > 1) sort_coords_index (X1, Y1, N1, Nstars);
    7979 
    8080  /* build spatial index (RA sort) */
    8181  for (i = 0; i < Nave; i++) {
    82     fRD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
     82    RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
    8383    N2[i] = i;
    8484    catalog[0].found[N2[i]] = -1;
    8585  }
    86   if (Nave > 1) sort_lists (X2, Y2, N2, Nave);
     86  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    8787
    8888  /* set up pointers for linked list of measure */

  • trunk/Ohana/src/addstar/src/find_matches_closest.c

    r15743 r16040  
    55  int i, j, n, N, J, Jmin, status, Nstars;
    66  double RADIUS, RADIUS2, Rmin;
    7   float *X1, *Y1, *X2, *Y2;
    8   float dX, dY, dR;
     7  double *X1, *Y1, *X2, *Y2;
     8  double dX, dY, dR;
    99  int *N1, *N2,  *next_meas, *next_miss;
    1010  int Nave, NAVE, Nmeas, NMEAS, Nmiss, NMISS, Nmatch;
    … …  
    2121
    2222  /** allocate local arrays (stars) **/
    23   ALLOCATE (X1, float, NstarsIn);
    24   ALLOCATE (Y1, float, NstarsIn);
     23  ALLOCATE (X1, double, NstarsIn);
     24  ALLOCATE (Y1, double, NstarsIn);
    2525  ALLOCATE (N1, int,   NstarsIn);
    2626
    2727  /** allocate local arrays (catalog) **/
    2828  NAVE = Nave = catalog[0].Naverage;
    29   ALLOCATE (X2, float, NAVE);
    30   ALLOCATE (Y2, float, NAVE);
     29  ALLOCATE (X2, double, NAVE);
     30  ALLOCATE (Y2, double, NAVE);
    3131  ALLOCATE (N2, int,   NAVE);
    3232  ALLOCATE (catalog[0].found, int, NAVE);
    … …  
    6161  Nstars = 0;
    6262  for (i = 0; i < NstarsIn; i++) {
    63     status = fRD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].R, stars[i].D, &tcoords);
     63    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i].R, stars[i].D, &tcoords);
    6464    if (!status) continue;
    6565    N1[Nstars] = i;
    … …  
    7777    return (0);
    7878  }
    79   if (Nstars > 1) sort_lists (X1, Y1, N1, Nstars);
     79  if (Nstars > 1) sort_coords_index (X1, Y1, N1, Nstars);
    8080
    8181  /* build spatial index (RA sort) */
    8282  for (i = 0; i < Nave; i++) {
    83     fRD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
     83    RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
    8484    N2[i] = i;
    8585    catalog[0].found[N2[i]] = -1;
    8686  }
    87   if (Nave > 1) sort_lists (X2, Y2, N2, Nave);
     87  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    8888
    8989  /* set up pointers for linked list of measure, missing */

  • trunk/Ohana/src/addstar/src/find_matches_refstars.c

    r15743 r16040  
    55  int i, j, k, n, m, N, J;
    66  double RADIUS, RADIUS2;
    7   float *X1, *Y1, *X2, *Y2;
    8   float dX, dY, dR;
     7  double *X1, *Y1, *X2, *Y2;
     8  double dX, dY, dR;
    99  int *N1, *N2,  *next, *next_miss, last, last_miss;
    1010  int Nave, NAVE, Nmeas, NMEAS, Nmiss, NMISS, Nmatch;
    … …  
    1818
    1919  /** allocate local arrays (stars) **/
    20   ALLOCATE (X1, float, Nstars);
    21   ALLOCATE (Y1, float, Nstars);
     20  ALLOCATE (X1, double, Nstars);
     21  ALLOCATE (Y1, double, Nstars);
    2222  ALLOCATE (N1, int,   Nstars);
    2323
    … …  
    2525  Nave = catalog[0].Naverage;
    2626  NAVE = Nave + 1000;
    27   ALLOCATE (X2, float, NAVE);
    28   ALLOCATE (Y2, float, NAVE);
     27  ALLOCATE (X2, double, NAVE);
     28  ALLOCATE (Y2, double, NAVE);
    2929  ALLOCATE (N2, int, NAVE);
    3030  ALLOCATE (catalog[0].found, int, NAVE);
    … …  
    5959 
    6060  for (i = 0; i < Nstars; i++) {
    61     fRD_to_XY (&X1[i], &Y1[i], stars[i][0].R, stars[i][0].D, &tcoords);
     61    RD_to_XY (&X1[i], &Y1[i], stars[i][0].R, stars[i][0].D, &tcoords);
    6262    N1[i] = i;
    6363  }
    64   if (Nstars > 1) sort_lists (X1, Y1, N1, Nstars);
     64  if (Nstars > 1) sort_coords_index (X1, Y1, N1, Nstars);
    6565 
    6666  for (i = 0; i < Nave; i++) {
    67     fRD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
     67    RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
    6868    N2[i] = i;
    6969    catalog[0].found[N2[i]] = -1;
    7070  }
    71   if (Nave > 1) sort_lists (X2, Y2, N2, Nave);
     71  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    7272
    7373  /* set up pointers for linked list of measurements */

  • trunk/Ohana/src/delstar/Makefile

    r12842 r16040  
    3232$(SRC)/find_matches.$(ARCH).o     \
    3333$(SRC)/parse_time.$(ARCH).o       \
    34 $(SRC)/sort_lists.$(ARCH).o \
    3534$(SRC)/check_permissions.$(ARCH).o \
    3635$(SRC)/Shutdown.$(ARCH).o         

  • trunk/Ohana/src/fixcat/include/markstar.h

    r3466 r16040  
    3535typedef struct {
    3636  Coords coords;
    37   float *X, *Y;
     37  double *X, *Y;
    3838  int *N;
    3939  double RA[2], DEC[2];

  • trunk/Ohana/src/fixcat/src/find_bright_stars.c

    r2490 r16040  
    1010  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    1111  Coords *tcoords;
    12   float *X1, *Y1, *X2, *Y2;
     12  double *X1, *Y1, *X2, *Y2;
    1313  int *N1, *N2;
    1414  char *mark;
    … …  
    2525  Y2 = catstats[0].Y;
    2626  N2 = catstats[0].N;
    27   ALLOCATE (X1, float, Ngsc);
    28   ALLOCATE (Y1, float, Ngsc);
     27  ALLOCATE (X1, double, Ngsc);
     28  ALLOCATE (Y1, double, Ngsc);
    2929  ALLOCATE (N1, int, Ngsc);
    3030  ALLOCATE (mark, char, Nave);
    … …  
    3333  tcoords = &catstats[0].coords;
    3434  for (i = 0; i < Ngsc; i++) {
    35     fRD_to_XY (&X1[i], &Y1[i], GSCdata.average[i].R, GSCdata.average[i].D, tcoords);
     35    RD_to_XY (&X1[i], &Y1[i], GSCdata.average[i].R, GSCdata.average[i].D, tcoords);
    3636    N1[i] = i;
    3737  }
    38   if (Ngsc > 1) sort_lists (X1, Y1, N1, Ngsc);
     38  if (Ngsc > 1) sort_coords_index (X1, Y1, N1, Ngsc);
    3939 
    4040  /* first find stellar halos */

  • trunk/Ohana/src/fixcat/src/find_matches.c

    r2490 r16040  
    99  int i, j, k, n, m, N, M, first_j;
    1010  double X, Y, RADIUS, RADIUS2;
    11   float *X1, *Y1, *X2, *Y2;
    12   float dX, dY, dR;
     11  double *X1, *Y1, *X2, *Y2;
     12  double dX, dY, dR;
    1313  int *N1, *N2;
    1414  int Nstar, Nghost, Ng;
    … …  
    2727  N2 = catstats[0].N;
    2828
    29   ALLOCATE (X1, float, Nghost);
    30   ALLOCATE (Y1, float, Nghost);
     29  ALLOCATE (X1, double, Nghost);
     30  ALLOCATE (Y1, double, Nghost);
    3131  ALLOCATE (N1, int, Nghost);
    3232
    … …  
    3434  tcoords = &catstats[0].coords;
    3535  for (i = 0; i < Nghost; i++) {
    36     fRD_to_XY (&X1[i], &Y1[i], Ghostdata[0].average[i].R, Ghostdata[0].average[i].D, tcoords);
     36    RD_to_XY (&X1[i], &Y1[i], Ghostdata[0].average[i].R, Ghostdata[0].average[i].D, tcoords);
    3737    N1[i] = i;
    3838  }
    39   if (Nghost > 1) sort_lists (X1, Y1, N1, Nghost);
     39  if (Nghost > 1) sort_coords_index (X1, Y1, N1, Nghost);
    4040
    4141  /* choose a radius for matches */

  • trunk/Ohana/src/fixcat/src/gcatstats.c

    r7080 r16040  
    99  double RaCenter, DecCenter;
    1010  double MinRA, MaxRA, MinDEC, MaxDEC;
    11   float *X1, *Y1;
     11  double *X1, *Y1;
    1212  int *N1;
    1313  Coords tcoords;
    … …  
    4141
    4242  /** allocate local arrays **/
    43   ALLOCATE (catstats[0].X, float, catalog[0].Naverage);
    44   ALLOCATE (catstats[0].Y, float, catalog[0].Naverage);
     43  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
     44  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    4545  ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
    4646
    … …  
    5858  Y1 = catstats[0].Y;
    5959  for (i = 0; i < catalog[0].Naverage; i++, X1++, Y1++) {
    60     fRD_to_XY (X1, Y1, catalog[0].average[i].R, catalog[0].average[i].D, &catstats[0].coords);
     60    RD_to_XY (X1, Y1, catalog[0].average[i].R, catalog[0].average[i].D, &catstats[0].coords);
    6161    catstats[0].N[i] = i;
    6262  }
    63   if (catalog[0].Naverage > 1) sort_lists (catstats[0].X, catstats[0].Y, catstats[0].N, catalog[0].Naverage);
     63  if (catalog[0].Naverage > 1) sort_coords_index (catstats[0].X, catstats[0].Y, catstats[0].N, catalog[0].Naverage);
    6464 
    6565}

  • trunk/Ohana/src/fixcat/src/mark_trail.c

    r2490 r16040  
    1111{
    1212
    13   float *R, *D;
     13  double *R, *D;
    1414  int j, k, jj, kk, N, NPTS, marked, start, end, Nm;
    1515  int *good, *seq, *N1;

  • trunk/Ohana/src/fixcat/src/sorts.c

    r2490 r16040  
     1# include "markstar.h"
    12
     3void sort_seq (double *X, int *S, int N) {
    24
    3 sort_lists (X, Y, S, N)
    4 float *X, *Y;
    5 int *S, N;
    6 {
    7   int l,j,ir,i;
    8   double tX, tY, tS;
    9  
    10   l = N >> 1;
    11   ir = N - 1;
    12   for (;;) {
    13     if (l > 0) {
    14       l--;
    15       tX = X[l];
    16       tY = Y[l];
    17       tS = S[l];
    18     }
    19     else {
    20       tX = X[ir];
    21       X[ir] = X[0];
    22       tY = Y[ir];
    23       Y[ir] = Y[0];
    24       tS = S[ir];
    25       S[ir] = S[0];
    26       if (--ir == 0) {
    27         X[0] = tX;
    28         Y[0] = tY;
    29         S[0] = tS;
    30         return;
    31       }
    32     }
    33     i = l;
    34     j = (l << 1) + 1;
    35     while (j <= ir) {
    36       if (j < ir && X[j] < X[j+1]) j++;
    37       if (tX < X[j]) {
    38         X[i] = X[j];
    39         Y[i] = Y[j];
    40         S[i] = S[j];
    41         j += (i=j) + 1;
    42       }
    43       else j = ir + 1;
    44     }
    45     X[i] = tX;
    46     Y[i] = tY;
    47     S[i] = tS;
    48   }
     5# define SWAPFUNC(A,B){ \
     6  double dtmp = X[A]; X[A] = X[B]; X[B] = dtmp; \
     7  int    itmp = Y[A]; Y[A] = Y[B]; Y[B] = itmp; \
     8}
     9# define COMPARE(A,B)(X[A] < X[B])
     10
     11  OHANA_SORT (N, COMPARE, SWAPFUNC);
     12
     13# undef SWAPFUNC
     14# undef COMPARE
     15
    4916}
    5017
    51 sort_entries (X, Y, N)
    52      double *X, *Y;
    53      int N;
    54 {
    55   int l,j,ir,i;
    56   double tX, tY;
    57  
    58   l = N >> 1;
    59   ir = N - 1;
    60   for (;;) {
    61     if (l > 0) {
    62       l--;
    63       tX = X[l];
    64       tY = Y[l];
    65     }
    66     else {
    67       tX = X[ir];
    68       X[ir] = X[0];
    69       tY = Y[ir];
    70       Y[ir] = Y[0];
    71       if (--ir == 0) {
    72         X[0] = tX;
    73         Y[0] = tY;
    74         return;
    75       }
    76     }
    77     i = l;
    78     j = (l << 1) + 1;
    79     while (j <= ir) {
    80       if (j < ir && X[j] < X[j+1]) j++;
    81       if (tX < X[j]) {
    82         X[i] = X[j];
    83         Y[i] = Y[j];
    84         j += (i=j) + 1;
    85       }
    86       else j = ir + 1;
    87     }
    88     X[i] = tX;
    89     Y[i] = tY;
    90   }
    91 }
    92 
    93 
    94 
    95 sort (X, N)
    96      double *X;
    97      int N;
    98 {
    99   int l,j,ir,i;
    100   double tX;
    101  
    102   l = N >> 1;
    103   ir = N - 1;
    104   for (;;) {
    105     if (l > 0) {
    106       l--;
    107       tX = X[l];
    108     }
    109     else {
    110       tX = X[ir];
    111       X[ir] = X[0];
    112       if (--ir == 0) {
    113         X[0] = tX;
    114         return;
    115       }
    116     }
    117     i = l;
    118     j = (l << 1) + 1;
    119     while (j <= ir) {
    120       if (j < ir && X[j] < X[j+1]) j++;
    121       if (tX < X[j]) {
    122         X[i] = X[j];
    123         j += (i=j) + 1;
    124       }
    125       else j = ir + 1;
    126     }
    127     X[i] = tX;
    128   }
    129 }
    130 
    131 
    132 sort_seq (X, S, N)
    133      double *X;
    134      int *S;
    135      int N;
    136 {
    137   int l,j,ir,i;
    138   int tS;
    139   double tX;
    140  
    141   l = N >> 1;
    142   ir = N - 1;
    143   for (;;) {
    144     if (l > 0) {
    145       l--;
    146       tX = X[l];
    147       tS = S[l];
    148     }
    149     else {
    150       tX = X[ir];
    151       X[ir] = X[0];
    152       tS = S[ir];
    153       S[ir] = S[0];
    154       if (--ir == 0) {
    155         X[0] = tX;
    156         S[0] = tS;
    157         return;
    158       }
    159     }
    160     i = l;
    161     j = (l << 1) + 1;
    162     while (j <= ir) {
    163       if (j < ir && X[j] < X[j+1]) j++;
    164       if (tX < X[j]) {
    165         X[i] = X[j];
    166         S[i] = S[j];
    167         j += (i=j) + 1;
    168       }
    169       else j = ir + 1;
    170     }
    171     X[i] = tX;
    172     S[i] = tS;
    173   }
    174 }
    175 

  • trunk/Ohana/src/gastro/Makefile

    r13479 r16040  
    3131$(SRC)/gheader.$(ARCH).o \
    3232$(SRC)/ConfigInit.$(ARCH).o \
    33 $(SRC)/sort.$(ARCH).o \
    3433$(SRC)/gfitpoly.$(ARCH).o \
    3534$(SRC)/get_region_coords.$(ARCH).o \

  • trunk/Ohana/src/gastro/src/gfit.c

    r8299 r16040  
    5858    tmpN1[i] = i;
    5959  }
    60   if (N1 > 1) sort_lists (tmpX1, tmpY1, tmpN1, N1);
     60  if (N1 > 1) sort_coords_index (tmpX1, tmpY1, tmpN1, N1);
    6161
    6262   
    … …  
    128128    }
    129129
    130     if (N2 > 1) sort_lists (tmpX2, tmpY2, tmpN2, N2);
     130    if (N2 > 1) sort_coords_index (tmpX2, tmpY2, tmpN2, N2);
    131131   
    132132    /* find matched stars */

  • trunk/Ohana/src/gastro/src/gfitpoly.c

    r8299 r16040  
    6464    tmpN1[i] = i;
    6565  }
    66   if (N1 > 1) sort_lists (tmpX1, tmpY1, tmpN1, N1);
     66  if (N1 > 1) sort_coords_index (tmpX1, tmpY1, tmpN1, N1);
    6767  for (i = 0; i < N2; i++) {
    6868    tmpX2[i] = stars2[i].X;
    … …  
    7070    tmpN2[i] = i;
    7171  }
    72   if (N2 > 1) sort_lists (tmpX2, tmpY2, tmpN2, N2);
     72  if (N2 > 1) sort_coords_index (tmpX2, tmpY2, tmpN2, N2);
    7373 
    7474  /* choose iteration ranges */
    … …  
    119119        tmpN1[i] = i;
    120120      }
    121       if (N1 > 1) sort_lists (tmpX1, tmpY1, tmpN1, N1);
     121      if (N1 > 1) sort_coords_index (tmpX1, tmpY1, tmpN1, N1);
    122122      dX = dY = d2X = d2Y = N = 0;
    123123    }

  • trunk/Ohana/src/gastro/src/gstars.c

    r14590 r16040  
    99# include <sys/time.h>
    1010# include <time.h>
     11
     12void sort_stars_mag (SStars *stars, int N) {
     13
     14# define SWAPFUNC(A,B){ SStars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
     15# define COMPARE(A,B)(stars[A].mag < stars[B].mag)
     16
     17  OHANA_SORT (N, COMPARE, SWAPFUNC);
     18
     19# undef SWAPFUNC
     20# undef COMPARE
     21
     22}
    1123
    1224SStars *gstars (char *file, int *NSTARS, Coords *coords, int *NX, int *NY, double *dNdM) {
    … …  
    182194  }
    183195
    184   sort_stars (stars, N);  /* sorting by magnitude */
     196  sort_stars_mag (stars, N);  /* sorting by magnitude */
    185197  Nstars = N;
    186198
    … …  
    200212}
    201213
    202 void sort_stars (SStars *stars, int N) {
    203 
    204   int l,j,ir,i;
    205   SStars tempstar;
    206  
    207   l = N >> 1;
    208   ir = N - 1;
    209   for (;;) {
    210     if (l > 0) {
    211       tempstar = stars[--l];
    212     }
    213     else {
    214       tempstar = stars[ir];
    215       stars[ir] = stars[0];
    216       if (--ir == 0) {
    217         stars[0] = tempstar;
    218         return;
    219       }
    220     }
    221     i = l;
    222     j = (l << 1) + 1;
    223     while (j <= ir) {
    224       if (j < ir && stars[j].mag < stars[j+1].mag) ++j;
    225       if (tempstar.mag < stars[j].mag) {
    226         stars[i] = stars[j];
    227         j += (i=j) + 1;
    228       }
    229       else j = ir + 1;
    230     }
    231     stars[i] = tempstar;
    232   }
    233 }
    234 
    235 
    236214# if (0)
    237215

  • trunk/Ohana/src/gastro2/src/grid.c

    r8241 r16040  
    5555    ALLOCATE (ntmp, double, Nbin);
    5656    bcopy (N, ntmp, Nbin*sizeof(double));
    57     sort (ntmp, Nbin);
     57    dsort (ntmp, Nbin);
    5858    for (i = 0; (ntmp[i] == 0) && (i < Nbin); i++);
    5959    Nval = MIN (Nbin - 1, (int)(0.75*(Nbin - i)) + i);
    … …  
    168168  ALLOCATE (ntmp, double, Nbin);
    169169  bcopy (N, ntmp, Nbin*sizeof(double));
    170   sort (ntmp, Nbin);
     170  dsort (ntmp, Nbin);
    171171  for (i = 0; (ntmp[i] == 0) && (i < Nbin); i++);
    172172  Nval = MIN (Nbin - 1, (int)(0.75*(Nbin - i)) + i);

  • trunk/Ohana/src/gastro2/src/lumfunc.c

    r9728 r16040  
    6060
    6161  /* keep inner 80% */
    62   sort_lum (rbin, bin, lbin, Nb);
     62  dsortthree (rbin, bin, lbin, Nb);
    6363  for (j = 0, i = 0.1*Nb; i < 0.9*Nb; i++, j++) {
    6464    bin[j]  = bin[i];

  • trunk/Ohana/src/gastro2/src/sort.c

    r11081 r16040  
    11# include "gastro2.h"
    2 
    3 void sort_lum (double *R, double *X, double *Y, int N) {
    4 
    5   int l,j,ir,i;
    6   double tX, tY, tR;
    7  
    8   if (N < 2) return;
    9 
    10   l = N >> 1;
    11   ir = N - 1;
    12   for (;;) {
    13     if (l > 0) {
    14       l--;
    15       tX = X[l];
    16       tY = Y[l];
    17       tR = R[l];
    18     }
    19     else {
    20       tX    = X[ir];
    21       X[ir] = X[0];
    22       tY    = Y[ir];
    23       Y[ir] = Y[0];
    24       tR    = R[ir];
    25       R[ir] = R[0];
    26       if (--ir == 0) {
    27         X[0] = tX;
    28         Y[0] = tY;
    29         R[0] = tR;
    30         return;
    31       }
    32     }
    33     i = l;
    34     j = (l << 1) + 1;
    35     while (j <= ir) {
    36       if (j < ir && R[j] < R[j+1]) j++;
    37       if (tR < R[j]) {
    38         X[i] = X[j];
    39         Y[i] = Y[j];
    40         R[i] = R[j];
    41         j += (i=j) + 1;
    42       }
    43       else j = ir + 1;
    44     }
    45     X[i] = tX;
    46     Y[i] = tY;
    47     R[i] = tR;
    48   }
    49 }
    50 
    51 void sort_lists (double *X, double *Y, int *S, int N) {
    52 
    53   int l,j,ir,i;
    54   double tX, tY, tS;
    55  
    56   if (N < 2) return;
    57 
    58   l = N >> 1;
    59   ir = N - 1;
    60   for (;;) {
    61     if (l > 0) {
    62       l--;
    63       tX = X[l];
    64       tY = Y[l];
    65       tS = S[l];
    66     }
    67     else {
    68       tX = X[ir];
    69       X[ir] = X[0];
    70       tY = Y[ir];
    71       Y[ir] = Y[0];
    72       tS = S[ir];
    73       S[ir] = S[0];
    74       if (--ir == 0) {
    75         X[0] = tX;
    76         Y[0] = tY;
    77         S[0] = tS;
    78         return;
    79       }
    80     }
    81     i = l;
    82     j = (l << 1) + 1;
    83     while (j <= ir) {
    84       if (j < ir && X[j] < X[j+1]) j++;
    85       if (tX < X[j]) {
    86         X[i] = X[j];
    87         Y[i] = Y[j];
    88         S[i] = S[j];
    89         j += (i=j) + 1;
    90       }
    91       else j = ir + 1;
    92     }
    93     X[i] = tX;
    94     Y[i] = tY;
    95     S[i] = tS;
    96   }
    97 }
    98 
    99 void sort (double *X, int N) {
    100 
    101   int l,j,ir,i;
    102   double tmp;
    103 
    104   if (N < 2) return;
    105  
    106   l = N >> 1;
    107   ir = N - 1;
    108   for (;;) {
    109     if (l > 0) {
    110       l--;
    111       tmp = X[l];
    112     }
    113     else {
    114       tmp = X[ir];
    115       X[ir] = X[0];
    116       if (--ir == 0) {
    117         X[0] = tmp;
    118         return;
    119       }
    120     }
    121     i = l;
    122     j = (l << 1) + 1;
    123     while (j <= ir) {
    124       if (j < ir && X[j] < X[j+1]) j++;
    125       if (tmp < X[j]) {
    126         X[i] = X[j];
    127         j += (i=j) + 1;
    128       }
    129       else j = ir + 1;
    130     }
    131     X[i] = tmp;
    132   }
    133 }
    1342
    1353void sort_stars_mag (StarData *stars, int N) {
    1364
    137   int l,j,ir,i;
    138   StarData tempstar;
    139  
    140   if (N < 2) return;
     5# define SWAPFUNC(A,B){ StarData tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
     6# define COMPARE(A,B)(stars[A].M < stars[B].M)
    1417
    142   l = N >> 1;
    143   ir = N - 1;
    144   for (;;) {
    145     if (l > 0) {
    146       tempstar = stars[--l];
    147     }
    148     else {
    149       tempstar = stars[ir];
    150       stars[ir] = stars[0];
    151       if (--ir == 0) {
    152         stars[0] = tempstar;
    153         return;
    154       }
    155     }
    156     i = l;
    157     j = (l << 1) + 1;
    158     while (j <= ir) {
    159       if (j < ir && stars[j].M < stars[j+1].M) ++j;
    160       if (tempstar.M < stars[j].M) {
    161         stars[i] = stars[j];
    162         j += (i=j) + 1;
    163       }
    164       else j = ir + 1;
    165     }
    166     stars[i] = tempstar;
    167   }
     8  OHANA_SORT (N, COMPARE, SWAPFUNC);
     9
     10# undef SWAPFUNC
     11# undef COMPARE
     12
    16813}
    16914
    17015void sort_stars_X (StarData *stars, int N) {
    17116
    172   int l,j,ir,i;
    173   StarData tempstar;
    174  
    175   if (N < 2) return;
     17# define SWAPFUNC(A,B){ StarData tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
     18# define COMPARE(A,B)(stars[A].X < stars[B].X)
    17619
    177   l = N >> 1;
    178   ir = N - 1;
    179   for (;;) {
    180     if (l > 0) {
    181       tempstar = stars[--l];
    182     }
    183     else {
    184       tempstar = stars[ir];
    185       stars[ir] = stars[0];
    186       if (--ir == 0) {
    187         stars[0] = tempstar;
    188         return;
    189       }
    190     }
    191     i = l;
    192     j = (l << 1) + 1;
    193     while (j <= ir) {
    194       if (j < ir && stars[j].X < stars[j+1].X) ++j;
    195       if (tempstar.X < stars[j].X) {
    196         stars[i] = stars[j];
    197         j += (i=j) + 1;
    198       }
    199       else j = ir + 1;
    200     }
    201     stars[i] = tempstar;
    202   }
     20  OHANA_SORT (N, COMPARE, SWAPFUNC);
     21
     22# undef SWAPFUNC
     23# undef COMPARE
     24
    20325}
    204 
    205 

  • trunk/Ohana/src/gcompare/include/gcompare.h

    r2421 r16040  
    2828int                get_argument      PROTO((int, char **, char *));
    2929int                remove_argument   PROTO((int, int *, char **));
    30 void               sort              PROTO((data_type));
     30void               data_sort         PROTO((data_type));
    3131void               output            PROTO((data_type, data_type, match_type *, int, int, int, int, int));
    3232char              *nextword          PROTO((char *));

  • trunk/Ohana/src/gcompare/src/gcompare.c

    r2421 r16040  
    7171  fprintf (stderr, "list 2: %d values %d %d\n", data2.Nvalues, X2, Y2);
    7272
    73   sort (data1); fprintf (stderr, "sorted 1\n");
    74   sort (data2); fprintf (stderr, "sorted 2\n");
     73  data_sort (data1); fprintf (stderr, "sorted 1\n");
     74  data_sort (data2); fprintf (stderr, "sorted 2\n");
    7575
    7676  fprintf (stderr, "noauto: %e\n", noauto);

  • trunk/Ohana/src/gcompare/src/neighbors.c

    r2421 r16040  
    4646  fprintf (stderr, "list 1: %d values %d %d\n", data1.Nvalues, X1, Y1);
    4747
    48   sort (data1); fprintf (stderr, "sorted 1\n");
     48  data_sort (data1); fprintf (stderr, "sorted 1\n");
    4949
    5050  count_neighbors (data1, radius, DX, DY);

  • trunk/Ohana/src/gcompare/src/sort.c

    r2421 r16040  
    11# include "gcompare.h"
    22
    3 void sort (data)
    4 data_type data;
    5 {
    6   int l,j,ir,i, N;
    7   value_type temp;
     3void data_sort (data_type data) {
    84
    9   N = data.Nvalues;
    10   if (N == 1)
    11     return;
     5# define SWAPFUNC(A,B){ value_type tmp; tmp = data.values[A]; data.values[A] = data.values[B]; data.values[B] = tmp; }
     6# define COMPARE(A,B)(data.values[A].X < data.values[B].X)
    127
    13   l = N >> 1;
    14   ir = N - 1;
    15   for (;;) {
    16     if (l > 0) {
    17       temp = data.values[--l];
    18     }
    19     else {
    20       temp = data.values[ir];
    21       data.values[ir] = data.values[0];
    22       if (--ir == 0) {
    23         data.values[0] = temp;
    24         return;
    25       }
    26     }
    27     i = l;
    28     j = (l << 1) + 1;
    29     while (j <= ir) {
    30       if (j < ir && data.values[j].X < data.values[j+1].X) ++j;
    31       if (temp.X < data.values[j].X) {
    32         data.values[i]=data.values[j];
    33         j += (i=j) + 1;
    34       }
    35       else j = ir + 1;
    36     }
    37     data.values[i] = temp;
    38   }
     8  OHANA_SORT (data.Nvalues, COMPARE, SWAPFUNC);
     9
     10# undef SWAPFUNC
     11# undef COMPARE
     12
    3913}
    40 

  • trunk/Ohana/src/gophot/Makefile

    r12842 r16040  
    3333$(SRC)/shape.$(ARCH).o          $(SRC)/galaxy.$(ARCH).o \
    3434$(SRC)/transmask.$(ARCH).o      $(SRC)/cosmic.$(ARCH).o \
    35 $(SRC)/impaper2.$(ARCH).o       $(SRC)/sort.$(ARCH).o \
     35$(SRC)/impaper2.$(ARCH).o       \
    3636$(SRC)/oblit.$(ARCH).o          $(SRC)/toobright.$(ARCH).o \
    3737$(SRC)/Chisq.$(ARCH).o          $(SRC)/oblims.$(ARCH).o \

  • trunk/Ohana/src/gophot/src/fillerup.c

    r2473 r16040  
    5050  if (nsky == 0) return (FALSE);
    5151
    52   sort (ts, nsky);
     52  fsort (ts, nsky);
    5353  sky = ts[(int)(0.5*nsky)];
    5454  sum2 = sky;

  • trunk/Ohana/src/gophot/src/impaper2.c

    r2473 r16040  
    2020  if (nsort < 1) return (0);
    2121
    22   sort (zsort, nsort);
     22  fsort (zsort, nsort);
    2323       
    2424  sky = 0;

  • trunk/Ohana/src/gophot/src/mediansky.c

    r2473 r16040  
    44static int Nx, Ny;
    55static float fx, fy;
    6 sort (float *, int);
    76
    87int make_mediansky () {
    … …  
    5958      }
    6059
    61       sort (temp, n);
     60      fsort (temp, n);
    6261      value = temp[(int)(0.5*n)];
    6362
    … …  
    8685  memcpy (temp, mediansky, Npix*sizeof(float));
    8786
    88   sort (temp, Npix);
     87  fsort (temp, Npix);
    8988
    9089  *sky = temp[(int)(0.5*Npix)];

  • trunk/Ohana/src/gophot/src/paravg.c

    r2473 r16040  
    11# include "gophot.h"
     2
     3sortkey (int *index, float *key, int N) {
     4
     5# define SWAPFUNC(A,B){ \
     6  int   itmp; itmp = index[A]; index[A] = index[B]; index[B] = itmp; \
     7  float ftmp; ftmp = key[A]; key[A] = key[B]; key[B] = ftmp; \
     8}
     9# define COMPARE(A,B)(key[A] < key[B])
     10
     11  OHANA_SORT (N, COMPARE, SWAPFUNC);
     12
     13# undef SWAPFUNC
     14# undef COMPARE
     15
     16}
    217
    318paravg () {

  • trunk/Ohana/src/imclean/src/sort_stars.c

    r3519 r16040  
    11# include "imclean.h"
    22
    3 void sort_stars (SMPData *X, int N) {
     3void sort_stars (SMPData *stars, int N) {
    44
    5   int l,j,ir,i;
    6   SMPData tX;
    7  
    8   if (N < 1) return;
    9   l = N >> 1;
    10   ir = N - 1;
    11   for (;;) {
    12     if (l > 0) {
    13       l--;
    14       tX = X[l];
    15     }
    16     else {
    17       tX = X[ir];
    18       X[ir] = X[0];
    19       if (--ir == 0) {
    20         X[0] = tX;
    21         return;
    22       }
    23     }
    24     i = l;
    25     j = (l << 1) + 1;
    26     while (j <= ir) {
    27       if (j < ir && X[j].X < X[j+1].X) j++;
    28       if (tX.X < X[j].X) {
    29         X[i] = X[j];
    30         j += (i=j) + 1;
    31       }
    32       else j = ir + 1;
    33     }
    34     X[i] = tX;
    35   }
     5# define SWAPFUNC(A,B){ SMPData tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
     6# define COMPARE(A,B)(stars[A].X < stars[B].X)
     7
     8  OHANA_SORT (N, COMPARE, SWAPFUNC);
     9
     10# undef SWAPFUNC
     11# undef COMPARE
     12
    3613}

  • trunk/Ohana/src/imregister/Makefile

    r12842 r16040  
    142142$(BASEDIR)/version.$(ARCH).o      \
    143143$(BASEDIR)/parse_time.$(ARCH).o   \
    144 $(BASEDIR)/fits_scan_nchar.$(ARCH).o \
    145 $(BASEDIR)/sort.$(ARCH).o
     144$(BASEDIR)/fits_scan_nchar.$(ARCH).o
    146145
    147146$(SRC)/photcode-table.$(ARCH).o \

  • trunk/Ohana/src/imregister/base/sort.c

    r2803 r16040  
    11# include <string.h>
    2 
    3 void sort (float *value, int N) {
    4 
    5   int l,j,ir,i;
    6   float temp;
    7  
    8   if (N < 2) return;
    9   l = N >> 1;
    10   ir = N - 1;
    11   for (;;) {
    12     if (l > 0) {
    13       temp = value[--l];
    14     }
    15     else {
    16       temp = value[ir];
    17       value[ir] = value[0];
    18       if (--ir == 0) {
    19         value[0] = temp;
    20         return;
    21       }
    22     }
    23     i = l;
    24     j = (l << 1) + 1;
    25     while (j <= ir) {
    26       if (j < ir && value[j] < value[j+1]) ++j;
    27       if (temp < value[j]) {
    28         value[i]=value[j];
    29         j += (i=j) + 1;
    30       }
    31       else j = ir + 1;
    32     }
    33     value[i] = temp;
    34   }
    35 }
    36 
    37 void dsort (double *value, int N) {
    38 
    39   int l,j,ir,i;
    40   double temp;
    41  
    42   if (N < 2) return;
    43   l = N >> 1;
    44   ir = N - 1;
    45   for (;;) {
    46     if (l > 0) {
    47       temp = value[--l];
    48     }
    49     else {
    50       temp = value[ir];
    51       value[ir] = value[0];
    52       if (--ir == 0) {
    53         value[0] = temp;
    54         return;
    55       }
    56     }
    57     i = l;
    58     j = (l << 1) + 1;
    59     while (j <= ir) {
    60       if (j < ir && value[j] < value[j+1]) ++j;
    61       if (temp < value[j]) {
    62         value[i]=value[j];
    63         j += (i=j) + 1;
    64       }
    65       else j = ir + 1;
    66     }
    67     value[i] = temp;
    68   }
    69 }
    702
    713void sortstr (char **S, int *X, int N) {

  • trunk/Ohana/src/imregister/imreg/cadc.c

    r14590 r16040  
    212212    entry[i] = match[i];
    213213  }
    214   sortpair (index, entry, Nmatch);
     214  isortpair (index, entry, Nmatch);
    215215  *Index = index;
    216216  *Entry = entry;

  • trunk/Ohana/src/imregister/imreg/unique.c

    r3606 r16040  
    6363  return (match);
    6464}
     65
     66void sortstr (char **S, int *X, int N) {
     67
     68# define SWAPFUNC(A,B){ \
     69  char *tmp = S[A]; S[A] = S[B]; S[B] = tmp; \
     70  int  itmp = X[A]; X[A] = X[B]; X[B] = itmp; \
     71}
     72# define COMPARE(A,B)(strcmp(S[A], S[B]) < 0)
     73
     74  OHANA_SORT (N, COMPARE, SWAPFUNC);
     75
     76# undef SWAPFUNC
     77# undef COMPARE
     78
     79}

  • trunk/Ohana/src/libdvo/Makefile

    r15694 r16040  
    3636$(SRC)/version.$(ARCH).o         \
    3737$(SRC)/coordops.$(ARCH).o        \
     38$(SRC)/dvosorts.$(ARCH).o        \
    3839$(SRC)/dvo_photcode_ops.$(ARCH).o \
    3940$(SRC)/dvo_photcode_convert_elixir.$(ARCH).o \

  • trunk/Ohana/src/libdvo/include/dvo.h

    r15743 r16040  
    412412int        SkyTableSetFilenames    PROTO((SkyTable *sky, char *path, char *ext));
    413413
     414/* dvo-specific sorting functions */
     415void sortave (Average *ave, int N);
     416void sort_image_subset (Image *image, int *subset, int N);
     417void sort_coords_index (double *X, double *Y, int *S, int N);
     418void sort_stars_ra (Stars *stars, int N);
     419void sort_regions (SkyRegion *region, int N);
     420
    414421# endif

  • trunk/Ohana/src/libdvo/src/skyregion_gsc.c

    r12392 r16040  
    206206void SkyTableSort (SkyTable *table) {
    207207
    208   int i, j, l, ir, N;
    209208  SkyRegion *regions;
    210   SkyRegion tempregion;
    211   char *tempfile = NULL;
    212209  char **filename = NULL;
    213  
    214   N = table[0].Nregions;
     210
    215211  regions = table[0].regions;
    216212  filename = table[0].filename;
    217213
    218   if (N < 2) return;
    219   l = N >> 1;
    220   ir = N - 1;
    221   for (;;) {
    222     if (l > 0) {
    223       l--;
    224       tempregion = regions[l];
    225       if (filename) tempfile   = filename[l];
    226     } else {
    227       tempregion   = regions[ir];
    228       if (filename) tempfile     = filename[ir];
    229       regions[ir]   = regions[0];
    230       if (filename) filename[ir] = filename[0];
    231       if (--ir == 0) {
    232         regions[0]   = tempregion;
    233         if (filename) filename[0] = tempfile;
    234         return;
    235       }
    236     }
    237     i = l;
    238     j = (l << 1) + 1;
    239     while (j <= ir) {
    240       if (j < ir && regions[j].Rmin < regions[j+1].Rmin) ++j;
    241       if (tempregion.Rmin < regions[j].Rmin) {
    242         regions[i]   = regions[j];
    243         if (filename) filename[i] = filename[j];
    244         j += (i=j) + 1;
    245       }
    246       else j = ir + 1;
    247     }
    248     regions[i]   = tempregion;
    249     if (filename) filename[i] = tempfile;
    250   }
     214# define SWAPFUNC(A,B){ int tmp; \
     215  char     *tempfile = filename[A]; filename[A] = filename[B]; filename[B] = tempfile; \
     216  SkyRegion tempregion = regions[A]; regions[A] = regions[B]; regions[B] = tempregion; \
     217}
     218# define COMPARE(A,B)(regions[A].Rmin < regions[B].Rmin)
     219
     220  OHANA_SORT (table[0].Nregions, COMPARE, SWAPFUNC);
     221
     222# undef SWAPFUNC
     223# undef COMPARE
    251224}
    252225

  • trunk/Ohana/src/libohana/Makefile

    r12842 r16040  
    2727
    2828INCS = \
    29 $(DESTINC)/Xohana.h  \
    3029$(DESTINC)/ohana_allocate.h \
     30$(DESTINC)/ohana_sort.h \
    3131$(DESTINC)/ohana.h
    3232
    3333OBJS = \
    3434$(SRC)/ohana_allocate.$(ARCH).o  \
     35$(SRC)/sorts.$(ARCH).o           \
    3536$(SRC)/string.$(ARCH).o          \
    3637$(SRC)/findexec.$(ARCH).o        \

  • trunk/Ohana/src/libohana/include/ohana.h

    r14590 r16040  
    128128# define OHANA_WHITESPACE(c)(((c) == 0x09) || ((c) == 0x0a) || ((c) == 0x0b) || ((c) == 0x0b) || ((c) == 0x0c) || ((c) == 0x0d) || ((c) == 0x20))
    129129
     130// sorting is now defined as a macro call
     131# include <ohana_sort.h>
     132
    130133/* socket / pipe communication buffer */
    131134typedef struct {

  • trunk/Ohana/src/lightcurve/Makefile

    r12842 r16040  
    2626$(SRC)/get_info.$(ARCH).o       $(SRC)/make_table.$(ARCH).o \
    2727$(SRC)/lightcurve.$(ARCH).o     \
    28 $(SRC)/sort_seq.$(ARCH).o       \
    2928$(SRC)/help.$(ARCH).o
    3029

  • trunk/Ohana/src/lightcurve/src/sort_stars.c

    r2490 r16040  
    11# include "lightcurve.h"
    22
    3 void sort_stars (radec, stars, Nstars)
    4 int  **radec;
    5 Star  *stars;
    6 int    Nstars;
    7 {
     3// construct an index for the stars sorted by RA
     4void sort_stars (int **index, Star *stars, int Nstars) {
    85 
    96  int i;
    107  double *RAs;
    118
    12   ALLOCATE (radec[0], int, Nstars);
    13   ALLOCATE (RAs, double, Nstars);
     9  ALLOCATE (myIndex, int, Nstars);
    1410  for (i = 0; i < Nstars; i++) {
    15     radec[0][i] = i;
    16     RAs[i] = stars[i].RA;
     11    myIndex[i] = i;
    1712  }
    1813
    19   sort_seq (radec[0], RAs, Nstars);
    20   free (RAs);
     14# define SWAPFUNC(A,B){ int tmp = myIndex[A]; myIndex[A] = myIndex[B]; myIndex[B] = tmp; }
     15# define COMPARE(A,B)(stars[myIndex[A]].RA < stars[myIndex[B]].RA)
    2116
     17  OHANA_SORT (Nstars, COMPARE, SWAPFUNC);
     18
     19# undef SWAPFUNC
     20# undef COMPARE
     21
     22  *index = myIndex;
    2223}
    23 
    24 

  • trunk/Ohana/src/markrock/include/markrock.h

    r4828 r16040  
    44typedef struct {
    55  Coords coords;
    6   float *X, *Y;
     6  double *X, *Y;
    77  int *N;
    88  double RA[2], DEC[2];

  • trunk/Ohana/src/markrock/src/find_bright_stars.c

    r2490 r16040  
    11# include "markrock.h"
    22
    3 find_bright_stars (catalog, catstats)
    4 Catalog catalog[];
    5 CatStats catstats[];
    6 {
     3void find_bright_stars (Catalog *catalog, CatStats *catstats) {
    74
    85  int i, j, n, m, first_j, Nave, Ngsc, Nmark;
    … …  
    107  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    118  Coords *tcoords;
    12   float *X1, *Y1, *X2, *Y2;
     9  double *X1, *Y1, *X2, *Y2;
    1310  int *N1, *N2;
    1411  char *mark;
    … …  
    2522  Y2 = catstats[0].Y;
    2623  N2 = catstats[0].N;
    27   ALLOCATE (X1, float, Ngsc);
    28   ALLOCATE (Y1, float, Ngsc);
     24  ALLOCATE (X1, double, Ngsc);
     25  ALLOCATE (Y1, double, Ngsc);
    2926  ALLOCATE (N1, int, Ngsc);
    3027  ALLOCATE (mark, char, Nave);
    … …  
    3330  tcoords = &catstats[0].coords;
    3431  for (i = 0; i < Ngsc; i++) {
    35     fRD_to_XY (&X1[i], &Y1[i], GSCdata.average[i].R, GSCdata.average[i].D, tcoords);
     32    RD_to_XY (&X1[i], &Y1[i], GSCdata.average[i].R, GSCdata.average[i].D, tcoords);
    3633    N1[i] = i;
    3734  }
    38   if (Ngsc > 1) sort_lists (X1, Y1, N1, Ngsc);
     35  if (Ngsc > 1) sort_coords_index (X1, Y1, N1, Ngsc);
    3936 
    4037  /* first find stellar halos */

  • trunk/Ohana/src/markrock/src/find_rocks.c

    r2490 r16040  
    11# include "markrock.h"
    22
    3 Rocks *find_rocks (catalog, catstats, nrocks)
    4 Catalog catalog[];
    5 CatStats catstats[];
    6 int *nrocks;
    7 {
     3Rocks *find_rocks (Catalog *catalog, CatStats *catstats, int *nrocks) {
    84
    95  int i, j, k, n, m, N, M, first_j, NOBJECT, Nobject, Nrocks, NROCKS;
    106  double X, Y, RADIUS2;
    11   float *X1, *Y1;
    12   float dX, dY, dR;
     7  double *X1, *Y1;
     8  double dX, dY, dR;
    139  float dtime;
    1410  int *N1, *N0;
    … …  
    2925
    3026  NOBJECT = 1000;
    31   ALLOCATE (X1, float, NOBJECT);
    32   ALLOCATE (Y1, float, NOBJECT);
     27  ALLOCATE (X1, double, NOBJECT);
     28  ALLOCATE (Y1, double, NOBJECT);
    3329  ALLOCATE (T1, int,   NOBJECT);
    3430  ALLOCATE (N1, int,   NOBJECT);
    … …  
    6864      if (Nobject == NOBJECT - 1) {
    6965        NOBJECT += 1000;
    70         REALLOCATE (X1, float, NOBJECT);
    71         REALLOCATE (Y1, float, NOBJECT);
     66        REALLOCATE (X1, double, NOBJECT);
     67        REALLOCATE (Y1, double, NOBJECT);
    7268        REALLOCATE (T1, int, NOBJECT);
    7369        REALLOCATE (N1, int,   NOBJECT);
    … …  
    7571    }
    7672  }
    77   REALLOCATE (X1, float, Nobject);
    78   REALLOCATE (Y1, float, Nobject);
     73  REALLOCATE (X1, double, Nobject);
     74  REALLOCATE (Y1, double, Nobject);
    7975  REALLOCATE (T1, int, Nobject);
    8076  REALLOCATE (N1, int,   Nobject);

  • trunk/Ohana/src/markrock/src/gcatstats.c

    r7080 r16040  
    99  double RaCenter, DecCenter;
    1010  double MinRA, MaxRA, MinDEC, MaxDEC;
    11   float *X1, *Y1;
     11  double *X1, *Y1;
    1212  int *N1;
    1313  Coords tcoords;
    … …  
    2929
    3030  /** allocate local arrays **/
    31   ALLOCATE (catstats[0].X, float, catalog[0].Naverage);
    32   ALLOCATE (catstats[0].Y, float, catalog[0].Naverage);
     31  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
     32  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    3333  ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
    3434
    … …  
    4949    catstats[0].N[i] = i;
    5050  }
    51   if (catalog[0].Naverage > 1) sort_lists (catstats[0].X, catstats[0].Y, catstats[0].N, catalog[0].Naverage);
     51  if (catalog[0].Naverage > 1) sort_coords_index (catstats[0].X, catstats[0].Y, catstats[0].N, catalog[0].Naverage);
    5252 
    5353}

  • trunk/Ohana/src/markrock/src/sorts.c

    r2490 r16040  
     1# include "markrock.h"
    12
    2 sort_set (X, Y, T, S, N)
    3 float *X, *Y;
    4 int *S, N;
    5 int *T;
    6 {
    7   int l,j,ir,i;
    8   unsigned int tT;
    9   double tX, tY, tS;
    10  
    11   l = N >> 1;
    12   ir = N - 1;
    13   for (;;) {
    14     if (l > 0) {
    15       l--;
    16       tX = X[l];
    17       tY = Y[l];
    18       tT = T[l];
    19       tS = S[l];
    20     }
    21     else {
    22       tX = X[ir];
    23       X[ir] = X[0];
    24       tY = Y[ir];
    25       Y[ir] = Y[0];
    26       tT = T[ir];
    27       T[ir] = T[0];
    28       tS = S[ir];
    29       S[ir] = S[0];
    30       if (--ir == 0) {
    31         X[0] = tX;
    32         Y[0] = tY;
    33         T[0] = tT;
    34         S[0] = tS;
    35         return;
    36       }
    37     }
    38     i = l;
    39     j = (l << 1) + 1;
    40     while (j <= ir) {
    41       if (j < ir && X[j] < X[j+1]) j++;
    42       if (tX < X[j]) {
    43         X[i] = X[j];
    44         Y[i] = Y[j];
    45         T[i] = T[j];
    46         S[i] = S[j];
    47         j += (i=j) + 1;
    48       }
    49       else j = ir + 1;
    50     }
    51     X[i] = tX;
    52     Y[i] = tY;
    53     T[i] = tT;
    54     S[i] = tS;
    55   }
     3void sort_set (double *X, double *Y, int *T, int *S, int N) {
     4
     5# define SWAPFUNC(A,B){ double dtmp; int itmp; \
     6  dtmp = X[A]; X[A] = X[B]; X[B] = dtmp; \
     7  dtmp = Y[A]; Y[A] = Y[B]; Y[B] = dtmp; \
     8  itmp = T[A]; T[A] = T[B]; T[B] = itmp; \
     9  itmp = S[A]; S[A] = S[B]; S[B] = itmp; \
    5610}
     11# define COMPARE(A,B)(X[A] < X[B])
    5712
     13  OHANA_SORT (N, COMPARE, SWAPFUNC);
    5814
    59 sort_lists (X, Y, S, N)
    60 float *X, *Y;
    61 int *S, N;
    62 {
    63   int l,j,ir,i;
    64   double tX, tY, tS;
    65  
    66   l = N >> 1;
    67   ir = N - 1;
    68   for (;;) {
    69     if (l > 0) {
    70       l--;
    71       tX = X[l];
    72       tY = Y[l];
    73       tS = S[l];
    74     }
    75     else {
    76       tX = X[ir];
    77       X[ir] = X[0];
    78       tY = Y[ir];
    79       Y[ir] = Y[0];
    80       tS = S[ir];
    81       S[ir] = S[0];
    82       if (--ir == 0) {
    83         X[0] = tX;
    84         Y[0] = tY;
    85         S[0] = tS;
    86         return;
    87       }
    88     }
    89     i = l;
    90     j = (l << 1) + 1;
    91     while (j <= ir) {
    92       if (j < ir && X[j] < X[j+1]) j++;
    93       if (tX < X[j]) {
    94         X[i] = X[j];
    95         Y[i] = Y[j];
    96         S[i] = S[j];
    97         j += (i=j) + 1;
    98       }
    99       else j = ir + 1;
    100     }
    101     X[i] = tX;
    102     Y[i] = tY;
    103     S[i] = tS;
    104   }
    105 }
    106 
    107 sort_entries (X, Y, N)
    108      double *X, *Y;
    109      int N;
    110 {
    111   int l,j,ir,i;
    112   double tX, tY;
    113  
    114   l = N >> 1;
    115   ir = N - 1;
    116   for (;;) {
    117     if (l > 0) {
    118       l--;
    119       tX = X[l];
    120       tY = Y[l];
    121     }
    122     else {
    123       tX = X[ir];
    124       X[ir] = X[0];
    125       tY = Y[ir];
    126       Y[ir] = Y[0];
    127       if (--ir == 0) {
    128         X[0] = tX;
    129         Y[0] = tY;
    130         return;
    131       }
    132     }
    133     i = l;
    134     j = (l << 1) + 1;
    135     while (j <= ir) {
    136       if (j < ir && X[j] < X[j+1]) j++;
    137       if (tX < X[j]) {
    138         X[i] = X[j];
    139         Y[i] = Y[j];
    140         j += (i=j) + 1;
    141       }
    142       else j = ir + 1;
    143     }
    144     X[i] = tX;
    145     Y[i] = tY;
    146   }
    147 }
    148 
    149 
    150 
    151 sort (X, N)
    152      double *X;
    153      int N;
    154 {
    155   int l,j,ir,i;
    156   double tX;
    157  
    158   l = N >> 1;
    159   ir = N - 1;
    160   for (;;) {
    161     if (l > 0) {
    162       l--;
    163       tX = X[l];
    164     }
    165     else {
    166       tX = X[ir];
    167       X[ir] = X[0];
    168       if (--ir == 0) {
    169         X[0] = tX;
    170         return;
    171       }
    172     }
    173     i = l;
    174     j = (l << 1) + 1;
    175     while (j <= ir) {
    176       if (j < ir && X[j] < X[j+1]) j++;
    177       if (tX < X[j]) {
    178         X[i] = X[j];
    179         j += (i=j) + 1;
    180       }
    181       else j = ir + 1;
    182     }
    183     X[i] = tX;
    184   }
    185 }
    186 
    187 
    188 sort_seq (X, S, N)
    189      double *X;
    190      int *S;
    191      int N;
    192 {
    193   int l,j,ir,i;
    194   int tS;
    195   double tX;
    196  
    197   l = N >> 1;
    198   ir = N - 1;
    199   for (;;) {
    200     if (l > 0) {
    201       l--;
    202       tX = X[l];
    203       tS = S[l];
    204     }
    205     else {
    206       tX = X[ir];
    207       X[ir] = X[0];
    208       tS = S[ir];
    209       S[ir] = S[0];
    210       if (--ir == 0) {
    211         X[0] = tX;
    212         S[0] = tS;
    213         return;
    214       }
    215     }
    216     i = l;
    217     j = (l << 1) + 1;
    218     while (j <= ir) {
    219       if (j < ir && X[j] < X[j+1]) j++;
    220       if (tX < X[j]) {
    221         X[i] = X[j];
    222         S[i] = S[j];
    223         j += (i=j) + 1;
    224       }
    225       else j = ir + 1;
    226     }
    227     X[i] = tX;
    228     S[i] = tS;
    229   }
    230 }
    231 
     15# undef SWAPFUNC
     16# undef COMPARE

  • trunk/Ohana/src/markstar/include/markstar.h

    r4828 r16040  
    3838typedef struct {
    3939  Coords coords;
    40   float *X, *Y;
     40  double *X, *Y;
    4141  int *N;
    4242  double RA[2], DEC[2];

  • trunk/Ohana/src/markstar/src/find_bright_stars.c

    r8386 r16040  
    11# include "markstar.h"
    22
    3 find_bright_stars (catalog, catstats)
    4 Catalog catalog[];
    5 CatStats catstats[];
    6 {
     3void find_bright_stars (Catalog *catalog, CatStats *catstats) {
    74
    85  int i, j, n, m, first_j, Nave, Ngsc;
    … …  
    107  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    118  Coords *tcoords;
    12   float *X1, *Y1, *X2, *Y2;
     9  double *X1, *Y1, *X2, *Y2;
    1310  int *N1, *N2;
    1411  char *mark;
    … …  
    2623  Y2 = catstats[0].Y;
    2724  N2 = catstats[0].N;
    28   ALLOCATE (X1, float, Ngsc);
    29   ALLOCATE (Y1, float, Ngsc);
     25  ALLOCATE (X1, double, Ngsc);
     26  ALLOCATE (Y1, double, Ngsc);
    3027  ALLOCATE (N1, int, Ngsc);
    3128  ALLOCATE (mark, char, Nave);
    … …  
    3431  tcoords = &catstats[0].coords;
    3532  for (i = 0; i < Ngsc; i++) {
    36     fRD_to_XY (&X1[i], &Y1[i], GSCdata.average[i].R, GSCdata.average[i].D, tcoords);
     33    RD_to_XY (&X1[i], &Y1[i], GSCdata.average[i].R, GSCdata.average[i].D, tcoords);
    3734    N1[i] = i;
    3835  }
    39   if (Ngsc > 1) sort_lists (X1, Y1, N1, Ngsc);
     36  if (Ngsc > 1) sort_coords_index (X1, Y1, N1, Ngsc);
    4037 
    4138  /* first find stellar halos */

  • trunk/Ohana/src/markstar/src/find_matches.c

    r2490 r16040  
    11# include "markstar.h"
    22
    3 find_matches (catalog, catstats, Ghostdata, Nimage)
    4 CatStats catstats[];
    5 Catalog catalog[], Ghostdata[];
    6 int Nimage;
    7 {
     3int find_matches (Catalog *catalog, CatStats *catstats, Catalog *Ghostdata, int Nimage) {
    84
    95  int i, j, k, n, m, N, M, first_j;
    106  double X, Y, RADIUS, RADIUS2;
    11   float *X1, *Y1, *X2, *Y2;
    12   float dX, dY, dR;
     7  double *X1, *Y1, *X2, *Y2;
     8  double dX, dY, dR;
    139  int *N1, *N2;
    1410  int Nstar, Nghost, Ng;
    … …  
    2723  N2 = catstats[0].N;
    2824
    29   ALLOCATE (X1, float, Nghost);
    30   ALLOCATE (Y1, float, Nghost);
     25  ALLOCATE (X1, double, Nghost);
     26  ALLOCATE (Y1, double, Nghost);
    3127  ALLOCATE (N1, int, Nghost);
    3228
    … …  
    3430  tcoords = &catstats[0].coords;
    3531  for (i = 0; i < Nghost; i++) {
    36     fRD_to_XY (&X1[i], &Y1[i], Ghostdata[0].average[i].R, Ghostdata[0].average[i].D, tcoords);
     32    RD_to_XY (&X1[i], &Y1[i], Ghostdata[0].average[i].R, Ghostdata[0].average[i].D, tcoords);
    3733    N1[i] = i;
    3834  }
    39   if (Nghost > 1) sort_lists (X1, Y1, N1, Nghost);
     35  if (Nghost > 1) sort_coords_index (X1, Y1, N1, Nghost);
    4036
    4137  /* choose a radius for matches */

  • trunk/Ohana/src/markstar/src/gcatstats.c

    r7080 r16040  
    11# include "markstar.h"
    22
    3 gcatstats (catalog, catstats)
    4 Catalog catalog[];
    5 CatStats catstats[];
    6 {
     3void gcatstats (Catalog *catalog, CatStats *catstats) {
    74
    85  int i;
    96  double RaCenter, DecCenter;
    107  double MinRA, MaxRA, MinDEC, MaxDEC;
    11   float *X1, *Y1;
     8  double *X1, *Y1;
    129  int *N1;
    1310  Coords tcoords;
    … …  
    4239
    4340  /** allocate local arrays **/
    44   ALLOCATE (catstats[0].X, float, catalog[0].Naverage);
    45   ALLOCATE (catstats[0].Y, float, catalog[0].Naverage);
     41  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
     42  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    4643  ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
    4744
    … …  
    5956  Y1 = catstats[0].Y;
    6057  for (i = 0; i < catalog[0].Naverage; i++, X1++, Y1++) {
    61     fRD_to_XY (X1, Y1, catalog[0].average[i].R, catalog[0].average[i].D, &catstats[0].coords);
     58    RD_to_XY (X1, Y1, catalog[0].average[i].R, catalog[0].average[i].D, &catstats[0].coords);
    6259    catstats[0].N[i] = i;
    6360  }
    64   if (catalog[0].Naverage > 1) sort_lists (catstats[0].X, catstats[0].Y, catstats[0].N, catalog[0].Naverage);
     61  if (catalog[0].Naverage > 1) sort_coords_index (catstats[0].X, catstats[0].Y, catstats[0].N, catalog[0].Naverage);
    6562 
    6663}

  • trunk/Ohana/src/markstar/src/sorts.c

    r2490 r16040  
     1# include "markstar.h"
    12
     3void sort_seq (double *X, int *S, int N) {
    24
    3 sort_lists (X, Y, S, N)
    4 float *X, *Y;
    5 int *S, N;
    6 {
    7   int l,j,ir,i;
    8   double tX, tY, tS;
    9  
    10   l = N >> 1;
    11   ir = N - 1;
    12   for (;;) {
    13     if (l > 0) {
    14       l--;
    15       tX = X[l];
    16       tY = Y[l];
    17       tS = S[l];
    18     }
    19     else {
    20       tX = X[ir];
    21       X[ir] = X[0];
    22       tY = Y[ir];
    23       Y[ir] = Y[0];
    24       tS = S[ir];
    25       S[ir] = S[0];
    26       if (--ir == 0) {
    27         X[0] = tX;
    28         Y[0] = tY;
    29         S[0] = tS;
    30         return;
    31       }
    32     }
    33     i = l;
    34     j = (l << 1) + 1;
    35     while (j <= ir) {
    36       if (j < ir && X[j] < X[j+1]) j++;
    37       if (tX < X[j]) {
    38         X[i] = X[j];
    39         Y[i] = Y[j];
    40         S[i] = S[j];
    41         j += (i=j) + 1;
    42       }
    43       else j = ir + 1;
    44     }
    45     X[i] = tX;
    46     Y[i] = tY;
    47     S[i] = tS;
    48   }
     5# define SWAPFUNC(A,B){ \
     6  double dtmp; dtmp = X[A]; X[A] = X[B]; X[B] = dtmp; }
     7  int    itmp; itmp = S[A]; S[A] = S[B]; S[B] = itmp; }
     8# define COMPARE(A,B)(X[A] < X[B])
     9
     10  OHANA_SORT (N, COMPARE, SWAPFUNC);
     11
     12# undef SWAPFUNC
     13# undef COMPARE
     14
    4915}
    50 
    51 sort_entries (X, Y, N)
    52      double *X, *Y;
    53      int N;
    54 {
    55   int l,j,ir,i;
    56   double tX, tY;
    57  
    58   l = N >> 1;
    59   ir = N - 1;
    60   for (;;) {
    61     if (l > 0) {
    62       l--;
    63       tX = X[l];
    64       tY = Y[l];
    65     }
    66     else {
    67       tX = X[ir];
    68       X[ir] = X[0];
    69       tY = Y[ir];
    70       Y[ir] = Y[0];
    71       if (--ir == 0) {
    72         X[0] = tX;
    73         Y[0] = tY;
    74         return;
    75       }
    76     }
    77     i = l;
    78     j = (l << 1) + 1;
    79     while (j <= ir) {
    80       if (j < ir && X[j] < X[j+1]) j++;
    81       if (tX < X[j]) {
    82         X[i] = X[j];
    83         Y[i] = Y[j];
    84         j += (i=j) + 1;
    85       }
    86       else j = ir + 1;
    87     }
    88     X[i] = tX;
    89     Y[i] = tY;
    90   }
    91 }
    92 
    93 
    94 
    95 sort (X, N)
    96      double *X;
    97      int N;
    98 {
    99   int l,j,ir,i;
    100   double tX;
    101  
    102   l = N >> 1;
    103   ir = N - 1;
    104   for (;;) {
    105     if (l > 0) {
    106       l--;
    107       tX = X[l];
    108     }
    109     else {
    110       tX = X[ir];
    111       X[ir] = X[0];
    112       if (--ir == 0) {
    113         X[0] = tX;
    114         return;
    115       }
    116     }
    117     i = l;
    118     j = (l << 1) + 1;
    119     while (j <= ir) {
    120       if (j < ir && X[j] < X[j+1]) j++;
    121       if (tX < X[j]) {
    122         X[i] = X[j];
    123         j += (i=j) + 1;
    124       }
    125       else j = ir + 1;
    126     }
    127     X[i] = tX;
    128   }
    129 }
    130 
    131 
    132 sort_seq (X, S, N)
    133      double *X;
    134      int *S;
    135      int N;
    136 {
    137   int l,j,ir,i;
    138   int tS;
    139   double tX;
    140  
    141   l = N >> 1;
    142   ir = N - 1;
    143   for (;;) {
    144     if (l > 0) {
    145       l--;
    146       tX = X[l];
    147       tS = S[l];
    148     }
    149     else {
    150       tX = X[ir];
    151       X[ir] = X[0];
    152       tS = S[ir];
    153       S[ir] = S[0];
    154       if (--ir == 0) {
    155         X[0] = tX;
    156         S[0] = tS;
    157         return;
    158       }
    159     }
    160     i = l;
    161     j = (l << 1) + 1;
    162     while (j <= ir) {
    163       if (j < ir && X[j] < X[j+1]) j++;
    164       if (tX < X[j]) {
    165         X[i] = X[j];
    166         S[i] = S[j];
    167         j += (i=j) + 1;
    168       }
    169       else j = ir + 1;
    170     }
    171     X[i] = tX;
    172     S[i] = tS;
    173   }
    174 }
    175 

  • trunk/Ohana/src/misc/src/cubefilter.c

    r12902 r16040  
    109109
    110110}
    111 
    112 fsort (value, N)
    113 float value[];
    114 int N;
    115 {
    116   int l,j,ir,i;
    117   float temp;
    118  
    119   l = N >> 1;
    120   ir = N - 1;
    121   for (;;) {
    122     if (l > 0) {
    123       temp = value[--l];
    124     }
    125     else {
    126       temp = value[ir];
    127       value[ir] = value[0];
    128       if (--ir == 0) {
    129         value[0] = temp;
    130         return;
    131       }
    132     }
    133     i = l;
    134     j = (l << 1) + 1;
    135     while (j <= ir) {
    136       if (j < ir && value[j] < value[j+1]) ++j;
    137       if (temp < value[j]) {
    138         value[i]=value[j];
    139         j += (i=j) + 1;
    140       }
    141       else j = ir + 1;
    142     }
    143     value[i] = temp;
    144   }
    145 }

  • trunk/Ohana/src/mosastro/Makefile

    r12842 r16040  
    5454$(SRC)/rfits.$(ARCH).o \
    5555$(SRC)/rtext.$(ARCH).o \
    56 $(SRC)/sort.$(ARCH).o \
    5756$(SRC)/testcoords.$(ARCH).o \
    5857$(SRC)/transforms.$(ARCH).o \

  • trunk/Ohana/src/mosastro/src/match.c

    r7401 r16040  
    2323    Q[i] = refcat[i].Q;
    2424  }
    25   sortthree (P, Q, U, Nrefcat);
    26 
     25  sort_coords_index (P, Q, U, Nrefcat);
    2726
    2827  for (i = 0; i < Nchip; i++) {
    … …  
    4241      q[j] = chip[i].stars[j].Q;
    4342    }
    44     sortthree (p, q, u, chip[i].Nstars);
     43    sort_coords_index (p, q, u, chip[i].Nstars);
    4544
    4645    /* find star matches in the tangent plane coord system */

  • trunk/Ohana/src/opihi/dvo/dvomisc.c

    r7680 r16040  
    3333
    3434}
    35 
    36 /* values are ave[i].R, ave[i].D, ave[i].M */
    37 void sortave (Average *ave, int N) {
    38 
    39   int l,j,ir,i;
    40   Average tmp;
    41 
    42   if (N < 2) return;
    43   l = N >> 1;
    44   ir = N - 1;
    45   for (;;) {
    46     if (l > 0) {
    47       l--;
    48       tmp = ave[l];
    49     }
    50     else {
    51       tmp = ave[ir];
    52       ave[ir] = ave[0];
    53       if (--ir == 0) {
    54         ave[0] = tmp;
    55         return;
    56       }
    57     }
    58     i = l;
    59     j = (l << 1) + 1;
    60     while (j <= ir) {
    61       if (j < ir && ave[j].R < ave[j+1].R) j++;
    62       if (tmp.R < ave[j].R) {
    63         ave[i] = ave[j];
    64         j += (i=j) + 1;
    65       }
    66       else j = ir + 1;
    67     }
    68     ave[i] = tmp;
    69   }
    70 }
    71 
    72 /** this does not seem to be used at the moment */
    73 /* values are ave[i].R, ave[i].D, ave[i].M */
    74 void sort_images (Image *image, int N) {
    75 
    76   int l,j,ir,i;
    77   Image tmp;
    78 
    79   if (N < 2) return;
    80   l = N >> 1;
    81   ir = N - 1;
    82   for (;;) {
    83     if (l > 0) {
    84       l--;
    85       tmp = image[l];
    86     }
    87     else {
    88       tmp = image[ir];
    89       image[ir] = image[0];
    90       if (--ir == 0) {
    91         image[0] = tmp;
    92         return;
    93       }
    94     }
    95     i = l;
    96     j = (l << 1) + 1;
    97     while (j <= ir) {
    98       if (j < ir && image[j].tzero < image[j+1].tzero) j++;
    99       if (tmp.tzero < image[j].tzero) {
    100         image[i] = image[j];
    101         j += (i=j) + 1;
    102       }
    103       else j = ir + 1;
    104     }
    105     image[i] = tmp;
    106   }
    107 }
    108 
    109 /* sort subset by image[subset[i]].tzero */
    110 void sort_image_subset (Image *image, int *subset, int N) {
    111 
    112   int l, j, ir, i, tmp;
    113 
    114   if (N < 2) return;
    115   l = N >> 1;
    116   ir = N - 1;
    117   for (;;) {
    118     if (l > 0) {
    119       l--;
    120       tmp = subset[l];
    121     }
    122     else {
    123       tmp = subset[ir];
    124       subset[ir] = subset[0];
    125       if (--ir == 0) {
    126         subset[0] = tmp;
    127         return;
    128       }
    129     }
    130     i = l;
    131     j = (l << 1) + 1;
    132     while (j <= ir) {
    133       if (j < ir && image[subset[j]].tzero < image[subset[j+1]].tzero) j++;
    134       if (image[tmp].tzero < image[subset[j]].tzero) {
    135         subset[i] = subset[j];
    136         j += (i=j) + 1;
    137       }
    138       else j = ir + 1;
    139     }
    140     subset[i] = tmp;
    141   }
    142 }

  • trunk/Ohana/src/opihi/dvo/fitsed.c

    r14401 r16040  
    436436SEDtableRow **sort_SEDtable (SEDtableRow *raw, int N) {
    437437
    438   int l,j,ir,i;
    439   SEDtableRow **value, *temp;
     438  int i;
     439  SEDtableRow **value;
    440440 
    441441  if (N <= 0) return (NULL);
    … …  
    445445    value[i] = &raw[i];
    446446  }
    447   if (N < 2) return (value);
    448 
    449   l = N >> 1;
    450   ir = N - 1;
    451   for (;;) {
    452     if (l > 0) {
    453       l--;
    454       temp = value[l];
    455     }
    456     else {
    457       temp = value[ir];
    458       value[ir] = value[0];
    459       if (--ir == 0) {
    460         value[0] = temp;
    461         return (value);
    462       }
    463     }
    464     i = l;
    465     j = (l << 1) + 1;
    466     while (j <= ir) {
    467       if (j < ir && value[j][0].color < value[j+1][0].color) ++j;
    468       if (temp[0].color < value[j][0].color) {
    469         value[i] = value[j];
    470         j += (i=j) + 1;
    471       }
    472       else j = ir + 1;
    473     }
    474     value[i] = temp;
    475   }
     447
     448# define SWAPFUNC(A,B){ SEDtableRow *temp = value[A]; value[A] = value[B]; value[B] = temp; }
     449# define COMPARE(A,B)(value[A][0].color < value[B][0].color)
     450
     451  OHANA_SORT (N, COMPARE, SWAPFUNC);
     452
     453# undef SWAPFUNC
     454# undef COMPARE
    476455
    477456  return (value);

  • trunk/Ohana/src/opihi/dvo/gstar.c

    r15509 r16040  
    1010  double Ra, Dec, Radius, Radius2, r, dec0, dec1;
    1111  double Mcat, Mrel;
    12   float *RA, *DEC;
     12  double *RA, *DEC;
    1313  int i, j, k, m, N, *N1, Nsecfilt, NPTS, QUIET, FULL_OUTPUT;
    1414  int Nstars, found, GetMeasures, Nlo, Nhi;
    … …  
    9393
    9494  Nstars = catalog.Naverage;
    95   ALLOCATE (RA, float, Nstars);
    96   ALLOCATE (DEC, float, Nstars);
     95  ALLOCATE (RA, double, Nstars);
     96  ALLOCATE (DEC, double, Nstars);
    9797  ALLOCATE (N1, int, Nstars);
    9898
    … …  
    105105  }
    106106  /* sort list by DEC */
    107   if (Nstars > 1) sort_lists (DEC, RA, N1, Nstars);
     107  if (Nstars > 1) sort_coords_index (DEC, RA, N1, Nstars);
    108108  /* at this point, RA, DEC, and N1 are sorted by DEC. 
    109109     catalog.average[N1[i]].R = RA[i] */
    … …  
    308308  }
    309309
    310   isort_pair (codeNumber, sequence, Nsecfilt);
     310  isortpair (codeNumber, sequence, Nsecfilt);
    311311  free (codeNumber);
    312312}

  • trunk/Ohana/src/opihi/dvo/lcurve.c

    r14401 r16040  
    55  char string[128], *p;
    66  double Ra, Dec, Radius, Radius2, r;
    7   float *RA, *DEC;
     7  double *RA, *DEC;
    88  int kapa, TimeFormat;
    99  int Nstars, found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
    … …  
    8686
    8787  Nstars = catalog.Naverage;
    88   ALLOCATE (RA, float, Nstars);
    89   ALLOCATE (DEC, float, Nstars);
     88  ALLOCATE (RA, double, Nstars);
     89  ALLOCATE (DEC, double, Nstars);
    9090  ALLOCATE (N1, int, Nstars);
    9191
    … …  
    9898  }
    9999  /* sort list by DEC */
    100   if (Nstars > 1) sort_lists (DEC, RA, N1, Nstars);
     100  if (Nstars > 1) sort_coords_index (DEC, RA, N1, Nstars);
    101101  /* at this point, RA, DEC, and N1 are sorted by DEC. 
    102102     catalog.average[N1[i]].R = RA[i] */
    … …  
    142142 
    143143  if (ErrorBars)
    144     sortthree (Xvec.elements, Yvec.elements, dYvec.elements, N);
     144    fsortthree (Xvec.elements, Yvec.elements, dYvec.elements, N);
    145145  else
    146146    fsortpair (Xvec.elements, Yvec.elements, N);

  • trunk/Ohana/src/opihi/dvo/lightcurve.c

    r14401 r16040  
    44 
    55  double Ra, Dec, Radius, Radius2, r;
    6   float *RA, *DEC;
     6  double *RA, *DEC;
    77  int Nstars, found, PhotCodeSelect;
    88  int i, j, k, m, N, NPTS, Nsecfilt, RELPHOT, *N1, TimeFormat;
    … …  
    6969
    7070  Nstars = catalog.Naverage;
    71   ALLOCATE (RA, float, Nstars);
    72   ALLOCATE (DEC, float, Nstars);
     71  ALLOCATE (RA, double, Nstars);
     72  ALLOCATE (DEC, double, Nstars);
    7373  ALLOCATE (N1, int, Nstars);
    7474
    … …  
    8181  }
    8282  /* sort list by DEC */
    83   if (Nstars > 1) sort_lists (DEC, RA, N1, Nstars);
     83  if (Nstars > 1) sort_coords_index (DEC, RA, N1, Nstars);
    8484  /* at this point, RA, DEC, and N1 are sorted by DEC. 
    8585     catalog.average[N1[i]].R = RA[i] */
    … …  
    134134    }
    135135  }
    136   sortthree (tvec[0].elements, mvec[0].elements, dmvec[0].elements, N);
     136  fsortthree (tvec[0].elements, mvec[0].elements, dmvec[0].elements, N);
    137137  tvec[0].Nelements = mvec[0].Nelements = dmvec[0].Nelements = N;
    138138

  • trunk/Ohana/src/opihi/dvo/subpix.c

    r15274 r16040  
    6060    index[i] = i;
    6161  }
    62   if (Nstars > 1) dsort_lists (DEC, RA, index, Nstars);
     62  if (Nstars > 1) sort_coords_index (DEC, RA, index, Nstars);
    6363
    6464  /* bracket the DEC range of interest */

  • trunk/Ohana/src/opihi/lib.data/Makefile

    r15274 r16040  
    1818$(SDIR)/book.$(ARCH).o                  \
    1919$(SDIR)/page.$(ARCH).o                  \
    20 $(SDIR)/sort.$(ARCH).o                  \
    2120$(SDIR)/fft.$(ARCH).o                   \
    2221$(SDIR)/svdcmp.$(ARCH).o                \

  • trunk/Ohana/src/opihi/lib.data/starfuncs.c

    r7917 r16040  
    3636    }
    3737  }
    38   sort (ring, Nring);
     38  dsort (ring, Nring);
    3939  for (Npts = sky = dsky2 = 0, i = 0.25*Nring; i < 0.75*Nring; i++, Npts += 1.0) {
    4040    sky += ring[i];
    … …  
    150150    }
    151151  }
    152   sort (sky, Nsky);
     152  dsort (sky, Nsky);
    153153  for (Npts = fsky = 0, i = 0.25*Nsky; i < 0.75*Nsky; i++, Npts += 1.0) {
    154154    fsky += sky[i];
    … …  
    199199    }
    200200  }
    201   sort (sky, Nsky);
     201  dsort (sky, Nsky);
    202202  for (Npts = fsky = 0, i = 0.25*Nsky; i < 0.75*Nsky; i++, Npts += 1.0) {
    203203    fsky += sky[i];

  • trunk/Ohana/src/opihi/lib.shell/CommandOps.c

    r14449 r16040  
    130130}
    131131
     132void sort_commands (int *seq) {
     133
     134  int i;
     135
     136  for (i = 0; i < Ncommands; i++) seq[i] = i;
     137
     138# define SWAPFUNC(A,B){ int tmp = seq[A]; seq[A] = seq[B]; seq[B] = tmp; }
     139# define COMPARE(A,B)(strcmp (commands[seq[A]].name, commands[seq[B]].name) < 0)
     140
     141  OHANA_SORT (Ncommands, COMPARE, SWAPFUNC);
     142
     143# undef SWAPFUNC
     144# undef COMPARE
     145 
     146}
     147
    132148void print_commands (FILE *f) {
    133149
    … …  
    143159  return;
    144160}
    145 
    146 void sort_commands (int *seq) {
    147 
    148   int l,j,ir,i, N;
    149   int temp;
    150  
    151   N = Ncommands;
    152   for (i = 0; i < N; i++)
    153     seq[i] = i;
    154  
    155   l = N >> 1;
    156   ir = N - 1;
    157   for (;;) {
    158     if (l > 0) {
    159       temp = seq[--l];
    160     }
    161     else {
    162       temp = seq[ir];
    163       seq[ir] = seq[0];
    164       if (--ir == 0) {
    165         seq[0] = temp;
    166         return;
    167       }
    168     }
    169     i = l;
    170     j = (l << 1) + 1;
    171     while (j <= ir) {
    172       if (j < ir && (strcmp (commands[seq[j]].name, commands[seq[j+1]].name) < 0)) ++j;
    173       if (strcmp (commands[temp].name, commands[seq[j]].name) < 0) {
    174         seq[i]=seq[j];
    175         j += (i=j) + 1;
    176       }
    177       else j = ir + 1;
    178     }
    179     seq[i] = temp;
    180   }
    181 }

  • trunk/Ohana/src/photdbc/src/join_stars.c

    r15743 r16040  
    66  int Naves, Nmeas, Ncurr;
    77  int Naverage, Nmeasure, *found, *index;
    8   float *X, *Y, dX, dY, dR, RADIUS2;
     8  double *X, *Y, dX, dY, dR, RADIUS2;
    99  double Sr, Sd, Rmid, Dmid;
    1010
    … …  
    4545 
    4646  /* project & sort coordinates in local linear frame */
    47   ALLOCATE (X, float, Naverage);
    48   ALLOCATE (Y, float, Naverage);
     47  ALLOCATE (X, double, Naverage);
     48  ALLOCATE (Y, double, Naverage);
    4949  ALLOCATE (index, int, Naverage);
    5050  for (i = 0; i < Naverage; i++) {
    5151    index[i] = i;
    52     fRD_to_XY (&X[i], &Y[i], average[i].R, average[i].D, &tcoords);
     52    RD_to_XY (&X[i], &Y[i], average[i].R, average[i].D, &tcoords);
    5353  }
    54   sort_lists (X, Y, index, Naverage);
     54  sort_coords_index (X, Y, index, Naverage);
    5555 
    5656  /* flags to mark if a star has been handled */
    … …  
    142142
    143143        /* update current reference star position */
    144         fRD_to_XY (&X[i], &Y[i], Sr, Sd, &tcoords);
     144        RD_to_XY (&X[i], &Y[i], Sr, Sd, &tcoords);
    145145      }
    146146    }

  • trunk/Ohana/src/photdbc/src/liststats.c

    r2494 r16040  
    3232  if (N < 2) return (FALSE);
    3333
    34   sortB (value, dvalue, N);
     34  dsortpair (value, dvalue, N);
    3535  stats[0].median = value[(int)(0.5*N)];
    3636  stats[0].min    = value[0];
    … …  
    6868      chi[i] = (value[i] - stats[0].median) / dvalue[i];
    6969    }
    70     sortD (chi, value, dvalue, N);
     70    dsortthree (chi, value, dvalue, N);
    7171    free (chi);
    7272  }

  • trunk/Ohana/src/photdbc/src/misc.c

    r2494 r16040  
    1 
    2 void sortA (double *X, int N) {
    3 
    4   int l,j,ir,i;
    5   double tX;
    6  
    7   if (N < 2) return;
    8 
    9   l = N >> 1;
    10   ir = N - 1;
    11   for (;;) {
    12     if (l > 0) {
    13       l--;
    14       tX = X[l];
    15     }
    16     else {
    17       tX = X[ir];
    18       X[ir] = X[0];
    19       if (--ir == 0) {
    20         X[0] = tX;
    21         return;
    22       }
    23     }
    24     i = l;
    25     j = (l << 1) + 1;
    26     while (j <= ir) {
    27       if (j < ir && X[j] < X[j+1]) j++;
    28       if (tX < X[j]) {
    29         X[i] = X[j];
    30         j += (i=j) + 1;
    31       }
    32       else j = ir + 1;
    33     }
    34     X[i] = tX;
    35   }
    36 }
    37 
    38 void sortB (double *X, double *Y, int N) {
    39 
    40   int l,j,ir,i;
    41   double tX, tY;
    42  
    43   if (N < 2) return;
    44 
    45   l = N >> 1;
    46   ir = N - 1;
    47   for (;;) {
    48     if (l > 0) {
    49       l--;
    50       tX = X[l];
    51       tY = Y[l];
    52     }
    53     else {
    54       tX = X[ir];
    55       X[ir] = X[0];
    56       tY = Y[ir];
    57       Y[ir] = Y[0];
    58       if (--ir == 0) {
    59         X[0] = tX;
    60         Y[0] = tY;
    61         return;
    62       }
    63     }
    64     i = l;
    65     j = (l << 1) + 1;
    66     while (j <= ir) {
    67       if (j < ir && X[j] < X[j+1]) j++;
    68       if (tX < X[j]) {
    69         X[i] = X[j];
    70         Y[i] = Y[j];
    71         j += (i=j) + 1;
    72       }
    73       else j = ir + 1;
    74     }
    75     X[i] = tX;
    76     Y[i] = tY;
    77   }
    78 }
    79 
    80 void sortC (double *X, double *Y, double *F1, double *F2, int N) {
    81 
    82   int l,j,ir,i;
    83   double tX, tY;
    84   double t1, t2;
    85  
    86   if (N < 2) return;
    87 
    88   l = N >> 1;
    89   ir = N - 1;
    90   for (;;) {
    91     if (l > 0) {
    92       l--;
    93       tX = X[l];
    94       tY = Y[l];
    95       t1 = F1[l];
    96       t2 = F2[l];
    97     }
    98     else {
    99       tX = X[ir];
    100       X[ir] = X[0];
    101       tY = Y[ir];
    102       Y[ir] = Y[0];
    103       t1 = F1[ir];
    104       F1[ir] = F1[0];
    105       t2 = F2[ir];
    106       F2[ir] = F2[0];
    107       if (--ir == 0) {
    108         X[0] = tX;
    109         Y[0] = tY;
    110         F1[0] = t1;
    111         F2[0] = t2;
    112         return;
    113       }
    114     }
    115     i = l;
    116     j = (l << 1) + 1;
    117     while (j <= ir) {
    118       if (j < ir && X[j] < X[j+1]) j++;
    119       if (tX < X[j]) {
    120         X[i] = X[j];
    121         Y[i] = Y[j];
    122         F1[i] = F1[j];
    123         F2[i] = F2[j];
    124         j += (i=j) + 1;
    125       }
    126       else j = ir + 1;
    127     }
    128     X[i] = tX;
    129     Y[i] = tY;
    130     F1[i] = t1;
    131     F2[i] = t2;
    132   }
    133 }
    134 
    135 void sortD (double *X, double *Y, double *Z, int N) {
    136 
    137   int l,j,ir,i;
    138   double tX, tY, tZ;
    139  
    140   if (N < 2) return;
    141 
    142   l = N >> 1;
    143   ir = N - 1;
    144   for (;;) {
    145     if (l > 0) {
    146       l--;
    147       tX = X[l];
    148       tY = Y[l];
    149       tZ = Z[l];
    150     }
    151     else {
    152       tX = X[ir];
    153       X[ir] = X[0];
    154       tY = Y[ir];
    155       Y[ir] = Y[0];
    156       tZ = Z[ir];
    157       Z[ir] = Z[0];
    158       if (--ir == 0) {
    159         X[0] = tX;
    160         Y[0] = tY;
    161         Z[0] = tZ;
    162         return;
    163       }
    164     }
    165     i = l;
    166     j = (l << 1) + 1;
    167     while (j <= ir) {
    168       if (j < ir && X[j] < X[j+1]) j++;
    169       if (tX < X[j]) {
    170         X[i] = X[j];
    171         Y[i] = Y[j];
    172         Z[i] = Z[j];
    173         j += (i=j) + 1;
    174       }
    175       else j = ir + 1;
    176     }
    177     X[i] = tX;
    178     Y[i] = tY;
    179     Z[i] = tZ;
    180   }
    181 }
    182 
    183 void sort_lists (float *X, float *Y, int *S, int N) {
    184 
    185   int l,j,ir,i;
    186   double tX, tY;
    187   int tS;
    188  
    189   if (N < 2) return;
    190 
    191   l = N >> 1;
    192   ir = N - 1;
    193   for (;;) {
    194     if (l > 0) {
    195       l--;
    196       tX = X[l];
    197       tY = Y[l];
    198       tS = S[l];
    199     }
    200     else {
    201       tX = X[ir];
    202       X[ir] = X[0];
    203       tY = Y[ir];
    204       Y[ir] = Y[0];
    205       tS = S[ir];
    206       S[ir] = S[0];
    207       if (--ir == 0) {
    208         X[0] = tX;
    209         Y[0] = tY;
    210         S[0] = tS;
    211         return;
    212       }
    213     }
    214     i = l;
    215     j = (l << 1) + 1;
    216     while (j <= ir) {
    217       if (j < ir && X[j] < X[j+1]) j++;
    218       if (tX < X[j]) {
    219         X[i] = X[j];
    220         Y[i] = Y[j];
    221         S[i] = S[j];
    222         j += (i=j) + 1;
    223       }
    224       else j = ir + 1;
    225     }
    226     X[i] = tX;
    227     Y[i] = tY;
    228     S[i] = tS;
    229   }
    230 }
     1# include "photdbc.h"
    2312
    2323void sort_time (unsigned int *X, int *Y, int N) {
    2334
    234   int l,j,ir,i;
    235   unsigned int tX;
    236   int tY;
    237  
    238   if (N < 2) return;
     5# define SWAPFUNC(A,B){ float tmp; \
     6  unsigned int utmp = X[A]; X[A] = X[B]; X[B] = utmp; \
     7  int          itmp = Y[A]; Y[A] = Y[B]; Y[B] = itmp; \
     8}
     9# define COMPARE(A,B)(X[A] < X[B])
    23910
    240   l = N >> 1;
    241   ir = N - 1;
    242   for (;;) {
    243     if (l > 0) {
    244       l--;
    245       tX = X[l];
    246       tY = Y[l];
    247     }
    248     else {
    249       tX = X[ir];
    250       X[ir] = X[0];
    251       tY = Y[ir];
    252       Y[ir] = Y[0];
    253       if (--ir == 0) {
    254         X[0] = tX;
    255         Y[0] = tY;
    256         return;
    257       }
    258     }
    259     i = l;
    260     j = (l << 1) + 1;
    261     while (j <= ir) {
    262       if (j < ir && X[j] < X[j+1]) j++;
    263       if (tX < X[j]) {
    264         X[i] = X[j];
    265         Y[i] = Y[j];
    266         j += (i=j) + 1;
    267       }
    268       else j = ir + 1;
    269     }
    270     X[i] = tX;
    271     Y[i] = tY;
    272   }
     11  OHANA_SORT (N, COMPARE, SWAPFUNC);
     12
     13# undef SWAPFUNC
     14# undef COMPARE
     15
    27316}

  • trunk/Ohana/src/relastro/Makefile

    r15600 r16040  
    4949$(SRC)/plotstuff.$(ARCH).o       \
    5050$(SRC)/select_images.$(ARCH).o   \
    51 $(SRC)/sort.$(ARCH).o            \
    5251$(SRC)/relastro.$(ARCH).o        \
    5352$(SRC)/save_catalogs.$(ARCH).o   \

  • trunk/Ohana/src/relastro/src/liststats.c

    r12332 r16040  
    3737  if (N < 1) return (FALSE);
    3838
    39   sortB (value, dvalue, N);
     39  dsortpair (value, dvalue, N);
    4040  stats[0].median = value[(int)(0.5*N)];
    4141  stats[0].min    = value[0];
    … …  
    7373      chi[i] = (value[i] - stats[0].median) / dvalue[i];
    7474    }
    75     sortD (chi, value, dvalue, N);
     75    dsortthree (chi, value, dvalue, N);
    7676    free (chi);
    7777  }

  • trunk/Ohana/src/relphot/Makefile

    r12842 r16040  
    4242$(SRC)/setExclusions.$(ARCH).o   \
    4343$(SRC)/setMrelFinal.$(ARCH).o    \
    44 $(SRC)/sort.$(ARCH).o            \
    4544$(SRC)/write_coords.$(ARCH).o
    4645

  • trunk/Ohana/src/relphot/src/liststats.c

    r5386 r16040  
    3737  if (N < 1) return (FALSE);
    3838
    39   sortB (value, dvalue, N);
     39  dsortpair (value, dvalue, N);
    4040  stats[0].median = value[(int)(0.5*N)];
    4141  stats[0].min    = value[0];
    … …  
    7373      chi[i] = (value[i] - stats[0].median) / dvalue[i];
    7474    }
    75     sortD (chi, value, dvalue, N);
     75    dsortthree (chi, value, dvalue, N);
    7676    free (chi);
    7777  }

  • trunk/Ohana/src/tools/src/medianfilter.c

    r16001 r16040  
    33
    44# define D_NFILES 100
    5 
    6 void fsort (float *value, int N);
    75
    86int main (int argc, char **argv) {
    … …  
    134132
    135133}
    136 
    137 void fsort (float *value, int N) {
    138 
    139   int l,j,ir,i;
    140   float temp;
    141  
    142   if (N < 2) return;
    143 
    144   l = N >> 1;
    145   ir = N - 1;
    146   for (;;) {
    147     if (l > 0) {
    148       temp = value[--l];
    149     }
    150     else {
    151       temp = value[ir];
    152       value[ir] = value[0];
    153       if (--ir == 0) {
    154         value[0] = temp;
    155         return;
    156       }
    157     }
    158     i = l;
    159     j = (l << 1) + 1;
    160     while (j <= ir) {
    161       if (j < ir && value[j] < value[j+1]) ++j;
    162       if (temp < value[j]) {
    163         value[i]=value[j];
    164         j += (i=j) + 1;
    165       }
    166       else j = ir + 1;
    167     }
    168     value[i] = temp;
    169   }
    170 }

  • trunk/Ohana/src/uniphot/src/find_image_tgroups.c

    r14590 r16040  
    1818    time[i] = image[i].tzero;
    1919  }
    20   sort (time, Nimage);
     20  sort_time (time, Nimage);
    2121
    2222  /* find groups with dt < TRANGE */

  • trunk/Ohana/src/uniphot/src/liststats.c

    r5386 r16040  
    3535  if (N < 2) return (FALSE);
    3636
    37   sortB (value, dvalue, N);
     37  dsortpair (value, dvalue, N);
    3838  stats[0].median = value[(int)(0.5*N)];
    3939  stats[0].min    = value[0];
    … …  
    7171      chi[i] = (value[i] - stats[0].median) / dvalue[i];
    7272    }
    73     sortD (chi, value, dvalue, N);
     73    dsortthree (chi, value, dvalue, N);
    7474    free (chi);
    7575  }

  • trunk/Ohana/src/uniphot/src/sort.c

    r8388 r16040  
    11# include "uniphot.h"
    22
    3 void sort (unsigned int *X, int N) {
     3void sort_time (unsigned int *value, int N) {
    44
    5   int l,j,ir,i;
    6   unsigned tX;
    7  
    8   if (N < 2) return;
     5# define SWAPFUNC(A,B){ unsigned int tmp = value[A]; value[A] = value[B]; value[B] = tmp; }
     6# define COMPARE(A,B)(value[A] < value[B])
    97
    10   l = N >> 1;
    11   ir = N - 1;
    12   for (;;) {
    13     if (l > 0) {
    14       l--;
    15       tX = X[l];
    16     }
    17     else {
    18       tX = X[ir];
    19       X[ir] = X[0];
    20       if (--ir == 0) {
    21         X[0] = tX;
    22         return;
    23       }
    24     }
    25     i = l;
    26     j = (l << 1) + 1;
    27     while (j <= ir) {
    28       if (j < ir && X[j] < X[j+1]) j++;
    29       if (tX < X[j]) {
    30         X[i] = X[j];
    31         j += (i=j) + 1;
    32       }
    33       else j = ir + 1;
    34     }
    35     X[i] = tX;
    36   }
     8  OHANA_SORT (N, COMPARE, SWAPFUNC);
     9
     10# undef SWAPFUNC
     11# undef COMPARE
     12
    3713}
    38 
    39 void sortB (double *X, double *Y, int N) {
    40 
    41   int l,j,ir,i;
    42   double tX, tY;
    43  
    44   if (N < 2) return;
    45 
    46   l = N >> 1;
    47   ir = N - 1;
    48   for (;;) {
    49     if (l > 0) {
    50       l--;
    51       tX = X[l];
    52       tY = Y[l];
    53     }
    54     else {
    55       tX = X[ir];
    56       X[ir] = X[0];
    57       tY = Y[ir];
    58       Y[ir] = Y[0];
    59       if (--ir == 0) {
    60         X[0] = tX;
    61         Y[0] = tY;
    62         return;
    63       }
    64     }
    65     i = l;
    66     j = (l << 1) + 1;
    67     while (j <= ir) {
    68       if (j < ir && X[j] < X[j+1]) j++;
    69       if (tX < X[j]) {
    70         X[i] = X[j];
    71         Y[i] = Y[j];
    72         j += (i=j) + 1;
    73       }
    74       else j = ir + 1;
    75     }
    76     X[i] = tX;
    77     Y[i] = tY;
    78   }
    79 }
    80 
    81 void sortD (double *X, double *Y, double *Z, int N) {
    82 
    83   int l,j,ir,i;
    84   double tX, tY, tZ;
    85  
    86   if (N < 2) return;
    87 
    88   l = N >> 1;
    89   ir = N - 1;
    90   for (;;) {
    91     if (l > 0) {
    92       l--;
    93       tX = X[l];
    94       tY = Y[l];
    95       tZ = Z[l];
    96     }
    97     else {
    98       tX = X[ir];
    99       X[ir] = X[0];
    100       tY = Y[ir];
    101       Y[ir] = Y[0];
    102       tZ = Z[ir];
    103       Z[ir] = Z[0];
    104       if (--ir == 0) {
    105         X[0] = tX;
    106         Y[0] = tY;
    107         Z[0] = tZ;
    108         return;
    109       }
    110     }
    111     i = l;
    112     j = (l << 1) + 1;
    113     while (j <= ir) {
    114       if (j < ir && X[j] < X[j+1]) j++;
    115       if (tX < X[j]) {
    116         X[i] = X[j];
    117         Y[i] = Y[j];
    118         Z[i] = Z[j];
    119         j += (i=j) + 1;
    120       }
    121       else j = ir + 1;
    122     }
    123     X[i] = tX;
    124     Y[i] = tY;
    125     Z[i] = tZ;
    126   }
    127 }
    128 
Note: See TracChangeset for help on using the changeset viewer.