// get_close.java  use heapsort to find indices in order by shortest distance
//                 given a point and a list of coordinates

public class get_close
{
  get_close()
  {
  }

  public void index2(double x, double y, 
                    double xp[], double yp[], int ixk[])
  {
    heapsort H = new heapsort();
    int n = xp.length;
    double far[] = new double[n];
    // build distances
    for(int i=0; i<n; i++)
    {
      far[i] = (x-xp[i])*(x-xp[i])+(y-yp[i])*(y-yp[i]);
      ixk[i] = i;
    }
    H.sortdindex(far, n, ixk); // ixk returned
  } // end index2

  public void sort2(double x, double y, 
                    double xp[], double yp[])
  {
    int n = xp.length;
    int ixk[] = new int[n];
    double s[] = new double[n]; // swap temp
    index2(x, y, xp, yp, ixk); // get sorting indices
    for(int i=0; i<n; i++) s[i] = xp[i];
    for(int i=0; i<n; i++) xp[i] = s[ixk[i]]; // physically sort
    for(int i=0; i<n; i++) s[i] = yp[i];      // swaping does not work
    for(int i=0; i<n; i++) yp[i] = s[ixk[i]];
  } // end sort2

  public void index3(double x, double y, double z, 
                    double xp[], double yp[], double zp[], int ixk[])
  {
    heapsort H = new heapsort();
    int n = xp.length;
    double far[] = new double[n];
    // build distances
    for(int i=0; i<n; i++)
    {
      far[i] = (x-xp[i])*(x-xp[i])+(y-yp[i])*(y-yp[i])+(z-zp[i])*(z-zp[i]);
      ixk[i] = i;
    }
    H.sortdindex(far, n, ixk); // ixk returned
  } // end index3

  public void sort3(double x, double y, double z, 
                    double xp[], double yp[], double zp[])
  {
    int n = xp.length;
    int ixk[] = new int[n];
    double s[] = new double[n]; // swap temp
    index3(x, y, z, xp, yp, zp, ixk); // get sorting indices
    for(int i=0; i<n; i++) s[i] = xp[i];
    for(int i=0; i<n; i++) xp[i] = s[ixk[i]]; // physically sort
    for(int i=0; i<n; i++) s[i] = yp[i];      // swaping does not work
    for(int i=0; i<n; i++) yp[i] = s[ixk[i]];
    for(int i=0; i<n; i++) s[i] = zp[i];
    for(int i=0; i<n; i++) zp[i] = s[ixk[i]];
  } // end sort3

  public void index4(double x, double y, double z, double t, 
                    double xp[], double yp[], double zp[], double tp[],
                    int ixk[])
  {
    heapsort H = new heapsort();
    int n = xp.length;
    double far[] = new double[n];
    // build distances
    for(int i=0; i<n; i++)
    {
      far[i] = (x-xp[i])*(x-xp[i])+(y-yp[i])*(y-yp[i])+
               (z-zp[i])*(z-zp[i])+(t-tp[i])*(t-tp[i]);
      ixk[i] = i;
    }
    H.sortdindex(far, n, ixk); // ixk returned
  } // end index4

  public void sort4(double x, double y, double z, double t, 
                    double xp[], double yp[], double zp[], double tp[])
  {
    int n = xp.length;
    int ixk[] = new int[n];
    double s[] = new double[n]; // swap temp
    index4(x, y, z, t, xp, yp, zp, tp, ixk); // get sorting indices
    for(int i=0; i<n; i++) s[i] = xp[i];
    for(int i=0; i<n; i++) xp[i] = s[ixk[i]]; // physically sort
    for(int i=0; i<n; i++) s[i] = yp[i];      // swaping does not work
    for(int i=0; i<n; i++) yp[i] = s[ixk[i]];
    for(int i=0; i<n; i++) s[i] = zp[i];
    for(int i=0; i<n; i++) zp[i] = s[ixk[i]];
    for(int i=0; i<n; i++) s[i] = tp[i];
    for(int i=0; i<n; i++) tp[i] = s[ixk[i]];
  } // end sort4

} // end class get_close