Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/Makefile
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/Makefile	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/Makefile	(revision 21732)
@@ -0,0 +1,26 @@
+default: gcompare
+help:
+	@echo "make options: gcompare (default)"
+
+include ../../Configure
+HOME 	=	$(ROOT)/src/gcompare
+BIN	=	$(HOME)/bin
+LIB	=	$(HOME)/lib
+MAN	=	$(HOME)/doc
+SRC	=	$(HOME)/src
+INC	=	$(HOME)/include
+include ../../Makefile.Common
+
+LDFLAGS := 	-ldvo -lFITS -lohana $(LDFLAGS)
+
+gcompare: $(BIN)/gcompare.$(ARCH)
+install: $(DESTBIN)/gcompare
+
+GCOMPARE 	= \
+$(SRC)/input.$(ARCH).o 				$(SRC)/output.$(ARCH).o    		\
+$(SRC)/compare.$(ARCH).o 			$(SRC)/sort.$(ARCH).o      		\
+$(SRC)/count_neighbors.$(ARCH).o                $(SRC)/nextline.$(ARCH).o		\
+$(SRC)/nextword.$(ARCH).o			$(SRC)/gcompare.$(ARCH).o
+
+$(GCOMPARE): $(INC)/gcompare.h
+$(BIN)/gcompare.$(ARCH): $(GCOMPARE)
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/bin/.cvsignore
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/bin/.cvsignore	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/bin/.cvsignore	(revision 21732)
@@ -0,0 +1,2 @@
+*.linux *.lin64 *.sol *.sun *.sid *.hp *.irix
+*.linrh
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/doc/gcompare.1
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/doc/gcompare.1	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/doc/gcompare.1	(revision 21732)
@@ -0,0 +1,52 @@
+.ad l
+.nh
+.TH gcompare 1.0 "Sept 18, 1992" "Version 1.0"
+.SH NAME
+\fIgcompare:\fP  2-D intercomparison between 2 files
+
+.SH SYNOPSIS
+.B gcompare [-d -m -n1 -n2 -s1 N -s2 N -c X Y] file1 X1 Y1 file2 X2 Y2 radius
+
+.SH DESCRIPTION
+\fIgcompare\fP takes two files and compares the entries with one with
+the entries in the second.  Two columns (X and Y) which contain the
+coordinates are given.  Lines in the second file with coordinates
+within the given radius of the first file are selected.  Depending on
+the optional flags, any of the following are printed:  
+1) the coordinate difference for these matched lines,
+2) both matched lines (concatenated into a single line)
+3) \fIunmatched\fP lines from file 1 
+4) \fIunmatched\fP lines from file 2 
+
+.SS OPTIONS
+.TP
+.I "-d"
+Include in the output the coordinate differences for the two files
+.TP
+.I "-m"
+Include in the output the matched lines from the two files
+.TP
+.I "-n1"
+Include in the output the unmatched lines from file 1
+.TP
+.I "-n2"
+Include in the output the unmatched lines from file 2
+.TP
+.I "-s1 N"
+skip the first N lines of file 1
+.TP
+.I "-s2 N"
+skip the first N lines of file 2
+.TP
+.I "-c X Y"
+offset the coordinates of file 2 by (X,Y)
+.TP
+.I "-h, -help"
+print a short help summary
+
+
+.SH COPYRIGHT
+Copyright 1993 Eugene Magnier
+.PP                                                
+.SH AUTHOR
+Eugene Magnier.  MIT - CSR, UvA
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/include/gcompare.h
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/include/gcompare.h	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/include/gcompare.h	(revision 21732)
@@ -0,0 +1,38 @@
+# include <math.h>
+# include <ohana.h>
+
+typedef struct {
+  double  X, Y;
+  char   *line;
+  int     match;
+} value_type;
+
+typedef struct {
+  value_type *values;
+  char       *buffer;
+  int        Nvalues;
+} data_type;
+
+
+typedef struct {
+  char *line1;
+  char *line2;
+  double dX, dY;
+} match_type;
+
+/******* PROTOTYPES ***********/
+
+void               help              PROTO(());
+data_type          input             PROTO((char *, int, int, int));
+match_type        *compare           PROTO((data_type, data_type, int *, double, double, double, double));
+int                get_argument      PROTO((int, char **, char *));
+int                remove_argument   PROTO((int, int *, char **));
+void               sort              PROTO((data_type));
+void               output            PROTO((data_type, data_type, match_type *, int, int, int, int, int));
+char              *nextword          PROTO((char *));
+int                parse             PROTO((double *, int, char *));
+char              *nextline          PROTO((char *));
+int                scan_line         PROTO((FILE *, char *));
+
+extern double hypot PROTO((double, double));
+/*  this seems to be a problem: is not included from math.h with the -ansi flag */
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/compare.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/compare.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/compare.c	(revision 21732)
@@ -0,0 +1,55 @@
+# include "gcompare.h"
+# define D_NMATCH 500;
+
+match_type *compare (data_type data1, data_type data2, int *Nmatches, double radius, double DX, double DY, double noauto) {
+
+  int i, j, first_j, Nmatch, NMATCH;
+  double dX, dY, dR;
+  match_type *match;
+
+  fprintf (stderr, "%f  %f\n", DX, DY);
+  Nmatch = 0;
+  NMATCH = D_NMATCH;
+  ALLOCATE (match, match_type, NMATCH);
+
+  for (i = j = 0;(i < data1.Nvalues) && (j < data2.Nvalues);) {
+    
+    dX = data1.values[i].X - data2.values[j].X - DX;
+
+    if (!(i % 100))
+      fprintf (stderr, ".");
+    
+    if (dX <= -radius)
+      i++;
+    if (dX >= radius)
+      j++;
+
+    if (fabs (dX) < radius) {
+      first_j = j;
+      for (j = first_j; (fabs (dX) < radius) && (j < data2.Nvalues); j++) {
+	dX = data1.values[i].X - data2.values[j].X - DX;
+	dY = data1.values[i].Y - data2.values[j].Y - DY;
+	dR = hypot (dX, dY);
+	if ((dR < radius) && ((noauto == 0) || (dR > noauto))) {
+	  match [Nmatch].line1 = data1.values[i].line;
+	  match [Nmatch].line2 = data2.values[j].line;
+	  match [Nmatch].dX = data1.values[i].X - data2.values[j].X - DX;
+	  match [Nmatch].dY = data1.values[i].Y - data2.values[j].Y - DY;
+	  data1.values[i].match = TRUE;
+	  data2.values[j].match = TRUE;
+	  Nmatch ++;
+	  if (Nmatch == NMATCH - 1) {
+	    NMATCH += D_NMATCH;
+	    REALLOCATE (match, match_type, NMATCH);
+	  }
+	}
+      }
+      j = first_j;
+      i++;
+    }
+
+  }
+  *Nmatches = Nmatch;
+  return (match);
+}
+
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/count_neighbors.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/count_neighbors.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/count_neighbors.c	(revision 21732)
@@ -0,0 +1,51 @@
+# include "gcompare.h"
+# define D_NMATCH 500;
+
+int count_neighbors (data, radius, DX, DY)
+data_type  data;
+double     radius;
+double     DX;
+double     DY;
+{
+
+  int i, j, first_j, Nfriends;
+  double dX, dY, dR;
+
+  fprintf (stderr, "%f  %f\n", DX, DY);
+
+  for (i = j = 0; (i < data.Nvalues) && (j < data.Nvalues);) {
+    
+    dX = data.values[i].X - data.values[j].X - DX;
+
+    if (!(i % 100))
+      fprintf (stderr, ".");
+    
+    Nfriends = 0;
+
+    if (dX <= -radius) {
+      fprintf (stdout, "%f %f %d\n", data.values[i].X, data.values[i].Y, Nfriends);
+      i++;
+    }
+    if (dX >= radius)
+      j++;
+
+    if (fabs (dX) < radius) {
+      first_j = j;
+      for (j = first_j; (fabs (dX) < radius) && (j < data.Nvalues); j++) {
+	if (i == j) continue;
+	dX = data.values[i].X - data.values[j].X - DX;
+	dY = data.values[i].Y - data.values[j].Y - DY;
+	dR = hypot (dX, dY);
+	if (dR < radius) {
+	  Nfriends ++;
+	}
+      }
+      j = first_j;
+      fprintf (stdout, "%f %f %d\n", data.values[i].X, data.values[i].Y, Nfriends);
+      i++;
+    }
+
+  }
+  return (TRUE);
+}
+
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/find_matches.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/find_matches.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/find_matches.c	(revision 21732)
@@ -0,0 +1,48 @@
+# include "gcompare.h"
+
+table_type *find_matches (table, values, Nvalues, catalog, Ncatalog, noauto)
+table_type   table[];
+value_type   values[];
+int          Nvalues;
+catalog_type catalog[];
+int          Ncatalog;
+int          noauto;
+{
+
+  int i, j, start, done;
+  double delta_Dec, dRA, dDec, radius;
+
+  delta_Dec = (catalog[Ncatalog - 1].Dec - catalog[0].Dec);
+  for (i = 0; i < Nvalues; i++) {
+    if ((values[i].Dec > catalog[Ncatalog - 1].Dec) || (values[i].Dec < catalog[0].Dec))
+      continue;
+    start = Ncatalog * (values[i].Dec - catalog[0].Dec) / delta_Dec;
+    done = FALSE;
+    while (!done) {
+      if ((catalog[start].Dec > values[i].Dec - values[i].radius) && (start != 0)) {
+	start -= 100;
+	if (start < 0)
+	  start = 0;
+      }
+      else
+	done = TRUE;
+    }
+    for (j = start; ((j < Ncatalog) && 
+		     (catalog[j].Dec < values[i].Dec + values[i].radius)); j++) {
+      dRA = (values[i].RA - catalog[j].RA) / cos (DEG_RAD*values[i].Dec);
+      dDec = values[i].Dec - catalog[j].Dec;
+      
+      radius = hypot (dRA, dDec);
+      if ((radius <= values[i].radius) && (!noauto || (radius > 0))) {
+	ALLOCATE (table[i].match[table[i].Nmatches], char, NBYTES_LINE + 1);
+	bzero (table[i].match[table[i].Nmatches], NBYTES_LINE + 1);
+	strcpy (table[i].match[table[i].Nmatches], catalog[j].line);
+	table[i].Nmatches ++;
+	if (table[i].Nmatches > 500)
+	  fprintf (stderr, "too many objects! \n");
+      }
+    }
+  }
+
+  return (table);
+}
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/gcompare.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/gcompare.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/gcompare.c	(revision 21732)
@@ -0,0 +1,101 @@
+# include "gcompare.h"
+
+int main (int argc, char **argv) {
+  
+  /* USAGE:  gcompare file1 X1 Y1 file2 X2 Y2 radius */
+  
+  int Nskip1, Nskip2, Nmatches, N;
+  int X1, X2, Y1, Y2, deltas, match, nomatch1, nomatch2;
+  data_type data1, data2;
+  match_type *matches;
+  double radius, DX, DY, noauto;
+
+  DX = DY = Nskip1 = Nskip2 = 0;
+  noauto = match = nomatch1 = nomatch2 = deltas = FALSE;
+
+  if (remove_argument(get_argument (argc, argv, "-d"), &argc, argv))
+    deltas = TRUE;
+  if (remove_argument(get_argument (argc, argv, "-h"), &argc, argv))
+    help();
+  if (remove_argument(get_argument (argc, argv, "-help"), &argc, argv))
+    help();
+  if (remove_argument(get_argument (argc, argv, "-m"), &argc, argv))
+    match = TRUE;
+  if (remove_argument(get_argument (argc, argv, "-n1"), &argc, argv))
+    nomatch1 = TRUE;
+  if (remove_argument(get_argument (argc, argv, "-n2"), &argc, argv))
+    nomatch2 = TRUE;
+  if (!(match || deltas || nomatch1 || nomatch2)) {
+    fprintf (stderr, "no output mode, use at least one of -d, -m, -n1, or -n2\n");
+    exit (2);
+  }
+  if ((N = get_argument (argc, argv, "-na"))) {
+    remove_argument(N, &argc, argv);
+    noauto = atof(argv[N]);
+    remove_argument(N, &argc, argv);
+  }
+    
+  if ((N = get_argument (argc, argv, "-c")) && (N + 2 < argc)) {
+    DX = atof(argv[N + 1]);
+    DY = atof(argv[N + 2]);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-s1"))) {
+    Nskip1 = atof(argv[N + 1]);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+  }
+  if ((N = get_argument (argc, argv, "-s2")) && (N + 1 < argc)) {
+    Nskip2 = atof(argv[N + 1]);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+  }
+  
+  if (argc != 8) {
+    fprintf (stderr, "gcompare [mode] file1 X1 Y1 file2 X2 Y2 radius\n");
+    exit (2);
+  }
+
+  X1 = atof (argv[2]);
+  Y1 = atof (argv[3]);
+  X2 = atof (argv[5]);
+  Y2 = atof (argv[6]);
+  radius = atof(argv[7]);
+  fprintf (stderr, "radius = %f %s\n", radius, argv[7]);
+
+  data1 = input (argv[1], X1, Y1, Nskip1);
+  fprintf (stderr, "list 1: %d values %d %d\n", data1.Nvalues, X1, Y1);
+  data2 = input (argv[4], X2, Y2, Nskip2);
+  fprintf (stderr, "list 2: %d values %d %d\n", data2.Nvalues, X2, Y2);
+
+  sort (data1); fprintf (stderr, "sorted 1\n");
+  sort (data2); fprintf (stderr, "sorted 2\n");
+
+  fprintf (stderr, "noauto: %e\n", noauto);
+  matches = compare (data1, data2, &Nmatches, radius, DX, DY, noauto);
+
+  output (data1, data2, matches, Nmatches, match, deltas, nomatch1, nomatch2);
+  exit (0);
+}
+
+
+
+void
+help() {
+
+  fprintf (stderr, "gcompare [mode] file1 X1 Y1 file2 X2 Y2 radius\n");
+  fprintf (stderr, " modes:\n");
+  fprintf (stderr, "  -d      return delta coords\n");
+  fprintf (stderr, "  -m      return matched lines\n");
+  fprintf (stderr, "  -n1     return unmatched lines, file 1\n");
+  fprintf (stderr, "  -n2     return unmatched lines, file 2\n");
+  fprintf (stderr, " additional options:\n");
+  fprintf (stderr, "  -c X Y    set offset (file1 - file2)\n");
+  fprintf (stderr, "  -s1 N     skip N lines from file 1\n");
+  fprintf (stderr, "  -s2 N     skip N lines from file 2\n");
+  fprintf (stderr, "  -na X     eliminate auto-matches (radius < X)\n");
+  exit (2);
+}
+
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/input.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/input.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/input.c	(revision 21732)
@@ -0,0 +1,65 @@
+# include "gcompare.h"
+# define D_NVALUES 1000
+# define D_NBYTES  10000
+
+data_type input (filename, X, Y, Nskip)
+char *filename;
+int   X;
+int   Y;
+int   Nskip;
+{
+  
+  data_type data;
+  int i, status, n, NVALUES, NBYTES, nbytes;
+  FILE *f;
+  char dummy_line[1000], *next;
+  
+  n = 0;
+
+  if (!strcmp (filename, "-")) {
+    f = stdin;
+  }
+  else {
+    f = fopen (filename, "r");
+    if (f == NULL) {
+      fprintf (stderr, "error opening file %s\n", filename);
+      exit (0);
+    }
+  }
+
+  for (i = 0; i < Nskip; i++) 
+    scan_line (f, dummy_line);
+ 
+  /* read in entire file */
+  NBYTES = D_NBYTES + 1;
+  ALLOCATE (data.buffer, char, NBYTES);
+  for (i = 0, nbytes = D_NBYTES; nbytes == D_NBYTES; i++) {
+    nbytes = fread (&data.buffer[i*D_NBYTES], 1, D_NBYTES, f);
+    NBYTES += D_NBYTES;
+    REALLOCATE (data.buffer, char, NBYTES);
+  }
+  NBYTES -= 2*D_NBYTES - nbytes;
+  data.buffer[NBYTES] = 0;
+  fprintf (stderr, "got %d bytes\n", NBYTES);
+
+  NVALUES = D_NVALUES;
+  ALLOCATE (data.values, value_type, NVALUES);
+  next = data.buffer;
+  for (i = 0; next != (char *) NULL; ) {
+    data.values[i].line  = next;
+    data.values[i].match = FALSE;
+    status  = dparse (&data.values[i].X, X, data.values[i].line);
+    status &= dparse (&data.values[i].Y, Y, data.values[i].line);
+    next = nextline (data.values[i].line);
+    if (status && (data.values[i].line[0] != '#')) {
+      i++;
+    }
+    if (i == NVALUES - 3) {
+      NVALUES += D_NVALUES;
+      REALLOCATE (data.values, value_type, NVALUES);
+    }
+  }
+  data.Nvalues = i;
+  return (data);
+}
+
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/neighbors.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/neighbors.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/neighbors.c	(revision 21732)
@@ -0,0 +1,72 @@
+# include "gcompare.h"
+
+void main (argc, argv)
+int    argc;
+char **argv;
+{
+  
+  /* USAGE:  gcompare file1 X1 Y1 file2 X2 Y2 radius */
+  
+  int i, Nskip1, Nskip2, Nmatches, N;
+  int X1, X2, Y1, Y2, deltas, match, nomatch1, nomatch2, noauto;
+  data_type data1, data2;
+  match_type *matches;
+  double radius, DX, DY;
+
+  DX = DY = Nskip1 = Nskip2 = 0;
+
+  if (remove_argument(get_argument (argc, argv, "-h"), &argc, argv))
+    help();
+  if (remove_argument(get_argument (argc, argv, "-help"), &argc, argv))
+    help();
+    
+  if ((N = get_argument (argc, argv, "-c")) && (N + 2 < argc)) {
+    DX = atof(argv[N + 1]);
+    DY = atof(argv[N + 2]);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+  }
+  if (N = get_argument (argc, argv, "-s1")) {
+    Nskip1 = atof(argv[N + 1]);
+    remove_argument(N, &argc, argv);
+    remove_argument(N, &argc, argv);
+  }
+  
+  if (argc != 5) {
+    fprintf (stderr, "neighbors [mode] file X Y radius\n");
+    exit (0);
+  }
+
+  X1 = atof (argv[2]);
+  Y1 = atof (argv[3]);
+  radius = atof(argv[4]);
+
+  data1 = input (argv[1], X1, Y1, Nskip1);
+  fprintf (stderr, "list 1: %d values %d %d\n", data1.Nvalues, X1, Y1);
+
+  sort (data1); fprintf (stderr, "sorted 1\n");
+
+  count_neighbors (data1, radius, DX, DY);
+
+}
+
+
+
+void
+help() {
+
+  fprintf (stderr, "gcompare [mode] file1 X1 Y1 file2 X2 Y2 radius\n");
+  fprintf (stderr, " modes:\n");
+  fprintf (stderr, "  -d      return delta coords\n");
+  fprintf (stderr, "  -m      return matched lines\n");
+  fprintf (stderr, "  -n1     return unmatched lines, file 1\n");
+  fprintf (stderr, "  -n2     return unmatched lines, file 2\n");
+  fprintf (stderr, " additional options:\n");
+  fprintf (stderr, "  -c X Y    set offset (file1 - file2)\n");
+  fprintf (stderr, "  -s1 N     skip N lines from file 1\n");
+  fprintf (stderr, "  -s2 N     skip N lines from file 2\n");
+  fprintf (stderr, "  -na X     eliminate auto-matches (radius < X)\n");
+  exit (0);
+}
+
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/nextline.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/nextline.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/nextline.c	(revision 21732)
@@ -0,0 +1,17 @@
+# include "gcompare.h"
+
+char *nextline (line)
+char line[];
+{
+
+  char *ret;
+  
+  ret = strchr (line, '\n');
+  if (ret != NULL) { 
+    *ret = 0;
+    ret += 1;
+  }
+
+  return (ret);
+}
+  
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/nextword.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/nextword.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/nextword.c	(revision 21732)
@@ -0,0 +1,12 @@
+# include "gcompare.h"
+
+char *nextword(string)
+char *string;
+{
+  if (string == (char *) NULL) return ((char *) NULL);
+
+  for (; isspace (*string); string++);
+  for (; (*string != 0) && !isspace (*string); string++);
+  for (; isspace (*string); string++);
+  return (string);
+}
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/output.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/output.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/output.c	(revision 21732)
@@ -0,0 +1,57 @@
+# include "gcompare.h"
+
+void output (data1, data2, matches, Nmatches, match, deltas, nomatch1, nomatch2)
+data_type  data1;
+data_type  data2;
+match_type matches[];
+int        Nmatches;
+int        match;
+int        deltas; 
+int        nomatch1;
+int        nomatch2;
+{
+
+  int i, Nmatch1, Nmatch2;
+
+  fprintf (stderr, "This is a Gcompare output list\n");
+  fprintf (stderr, "There are %d matches\n\n", Nmatches);
+  Nmatch1 = Nmatch2 = 0.0;
+
+  if (match || deltas) {
+    for (i = 0; i < Nmatches; i++) {
+      if (deltas)
+	fprintf (stdout, "%15.9f  %15.9f  ", matches[i].dX, matches[i].dY);
+      if (match)
+	fprintf (stdout, "%s  %s", matches[i].line1, matches[i].line2);
+      fprintf (stdout, "\n");
+    }
+  }
+
+  if (match && nomatch1) 
+    fprintf (stdout, "\n non-matces from file 1:\n");
+  
+  if (nomatch1) {
+    for (i = 0; i < data1.Nvalues; i++) {
+      if (!data1.values[i].match) {
+	fprintf (stdout, "%s\n", data1.values[i].line);
+	Nmatch1 ++;
+      }
+    }
+    fprintf (stderr, "no matches in file 1: %d\n", Nmatch1);
+  }
+
+  if ((match || nomatch1) && nomatch2)
+    fprintf (stdout, "\n non-matces from file 2:\n");
+
+  if (nomatch2) {
+    for (i = 0; i < data2.Nvalues; i++) {
+      if (!data2.values[i].match) {
+	fprintf (stdout, "%s\n", data2.values[i].line);
+	Nmatch2++;
+      }
+    }
+    fprintf (stderr, "no matches in file 2: %d\n", Nmatch2);
+  }
+
+
+}
Index: /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/sort.c
===================================================================
--- /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/sort.c	(revision 21732)
+++ /tags/ohana/gcompare-1-1-0/Ohana/src/gcompare/src/sort.c	(revision 21732)
@@ -0,0 +1,40 @@
+# include "gcompare.h"
+
+void sort (data)
+data_type data;
+{
+  int l,j,ir,i, N;
+  value_type temp;
+
+  N = data.Nvalues;
+  if (N == 1)
+    return;
+
+  l = N >> 1;
+  ir = N - 1;
+  for (;;) {
+    if (l > 0) {
+      temp = data.values[--l];
+    }
+    else {
+      temp = data.values[ir];
+      data.values[ir] = data.values[0];
+      if (--ir == 0) {
+        data.values[0] = temp;
+        return;
+      }
+    }
+    i = l;
+    j = (l << 1) + 1;
+    while (j <= ir) {
+      if (j < ir && data.values[j].X < data.values[j+1].X) ++j;
+      if (temp.X < data.values[j].X) {
+        data.values[i]=data.values[j];
+        j += (i=j) + 1;
+      }
+      else j = ir + 1;
+    }
+    data.values[i] = temp;
+  }
+}
+