IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 7, 2008, 3:31:01 PM (18 years ago)
Author:
eugene
Message:

big update from eam_branch_20081124 with updates to Opihi math

Location:
trunk/Ohana/src/opihi/cmd.data
Files:
57 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/cmd.data/accum.c

    r7917 r20936  
    55  int i, Nbins, bin, N, Normalize;
    66  float start, end, delta;
    7   float *V, *K, *O, *NV;
     7  int *NV;
     8  opihi_flt *V, *K, *O;
    89  Vector *val, *key, *out;
    910
    … …  
    2930  if ((out = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    3031
     32  REQUIRE_VECTOR_FLT (val, FALSE);
     33  REQUIRE_VECTOR_FLT (key, FALSE);
     34
    3135  start = atof (argv[4]);
    3236  end   = atof (argv[5]);
    … …  
    4549  Nbins = (end - start) / delta;
    4650
    47   out[0].Nelements = Nbins;
    48   REALLOCATE (out[0].elements, float, out[0].Nelements);
    49   bzero (out[0].elements, sizeof(float)*out[0].Nelements);
     51  ResetVector (out, OPIHI_FLT, Nbins);
     52  bzero (out[0].elements.Flt, sizeof(opihi_flt)*out[0].Nelements);
    5053  if (Normalize) {
    51     ALLOCATE (NV, float, Nbins);
    52     bzero (NV, sizeof(float)*Nbins);
     54    ALLOCATE (NV, int, Nbins);
     55    bzero (NV, sizeof(int)*Nbins);
    5356  }
    5457
    55   V = val[0].elements;
    56   K = key[0].elements;
    57   O = out[0].elements;
     58  V = val[0].elements.Flt;
     59  K = key[0].elements.Flt;
     60  O = out[0].elements.Flt;
    5861
    5962  for (i = 0; i < val[0].Nelements; i++, V++, K++) {

  • trunk/Ohana/src/opihi/cmd.data/applyfit.c

    r16428 r20936  
    11# include "data.h"
    2 
    3 char *get_variable (char *);
    42
    53int applyfit (int argc, char **argv) {
    … …  
    86  char *c, name[64];
    97  double *C, X;
    10   float *x, *y;
     8  opihi_flt *y;
    119  Vector *xvec, *yvec;
    1210
    … …  
    3836    free (c);
    3937  }
    40   yvec[0].Nelements = xvec[0].Nelements;
    41   REALLOCATE (yvec[0].elements, float, yvec[0].Nelements);
    42   bzero (yvec[0].elements, sizeof(float)*yvec[0].Nelements);
    43   x = xvec[0].elements;
    44   y = yvec[0].elements;
    4538
    46   for (j = 0; j < xvec[0].Nelements; j++, x++, y++) {
    47     X = 1;
    48     for (i = 0; i < order + 1; i++) {
    49       *y += C[i]*X;
    50       X = X * (*x);
     39  ResetVector (yvec, OPIHI_FLT, xvec[0].Nelements);
     40  bzero (yvec[0].elements.Flt, sizeof(opihi_flt)*yvec[0].Nelements);
     41  y = yvec[0].elements.Flt;
     42
     43  if (xvec[0].type == OPIHI_FLT) {
     44    opihi_flt *x = xvec[0].elements.Flt;
     45    for (j = 0; j < xvec[0].Nelements; j++, x++, y++) {
     46      X = 1;
     47      for (i = 0; i < order + 1; i++) {
     48        *y += C[i]*X;
     49        X = X * (*x);
     50      }
     51    }
     52  } else {
     53    opihi_int *x = xvec[0].elements.Int;
     54    for (j = 0; j < xvec[0].Nelements; j++, x++, y++) {
     55      X = 1;
     56      for (i = 0; i < order + 1; i++) {
     57        *y += C[i]*X;
     58        X = X * (*x);
     59      }
    5160    }
    5261  }

  • trunk/Ohana/src/opihi/cmd.data/applyfit2d.c

    r16428 r20936  
    11# include "data.h"
    2 
    3 char *get_variable (char *);
    42
    53int applyfit2d (int argc, char **argv) {
    … …  
    86  char *c, name[64];
    97  double **C, X, Y;
    10   float *x, *y, *z;
     8  opihi_flt *z;
    119  Vector *xvec, *yvec, *zvec;
    1210
    … …  
    4543  }
    4644
    47   zvec[0].Nelements = xvec[0].Nelements;
    48   REALLOCATE (zvec[0].elements, float, zvec[0].Nelements);
    49   bzero (zvec[0].elements, sizeof(float)*zvec[0].Nelements);
    50   x = xvec[0].elements;
    51   y = yvec[0].elements;
    52   z = zvec[0].elements;
     45  ResetVector (zvec, OPIHI_FLT, xvec[0].Nelements);
     46  bzero (zvec[0].elements.Flt, sizeof(opihi_flt)*zvec[0].Nelements);
     47  z = zvec[0].elements.Flt;
    5348
    54   for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {
    55     Y = X = 1;
    56     for (j = 0; j < order + 1; j++) {
    57       X = Y;
    58       for (i = 0; i < order + 1 - j; i++) {
    59         *z += C[i][j]*X;
    60         X = X * (*x);
     49  // we have four cases (x == flt or int) and (y == flt or int)
     50  if ((xvec[0].type == OPIHI_FLT) && (yvec[0].type == OPIHI_FLT)) {
     51    opihi_flt *x = xvec[0].elements.Flt;
     52    opihi_flt *y = yvec[0].elements.Flt;
     53    for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {
     54      Y = X = 1;
     55      for (j = 0; j < order + 1; j++) {
     56        X = Y;
     57        for (i = 0; i < order + 1 - j; i++) {
     58          *z += C[i][j]*X;
     59          X = X * (*x);
     60        }
     61        Y = Y * (*y);
    6162      }
    62       Y = Y * (*y);
    6363    }
    6464  }
     65  if ((xvec[0].type == OPIHI_FLT) && (yvec[0].type == OPIHI_INT)) {
     66    opihi_flt *x = xvec[0].elements.Flt;
     67    opihi_int *y = yvec[0].elements.Int;
     68    for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {
     69      Y = X = 1;
     70      for (j = 0; j < order + 1; j++) {
     71        X = Y;
     72        for (i = 0; i < order + 1 - j; i++) {
     73          *z += C[i][j]*X;
     74          X = X * (*x);
     75        }
     76        Y = Y * (*y);
     77      }
     78    }
     79  }
     80  if ((xvec[0].type == OPIHI_INT) && (yvec[0].type == OPIHI_FLT)) {
     81    opihi_int *x = xvec[0].elements.Int;
     82    opihi_flt *y = yvec[0].elements.Flt;
     83    for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {
     84      Y = X = 1;
     85      for (j = 0; j < order + 1; j++) {
     86        X = Y;
     87        for (i = 0; i < order + 1 - j; i++) {
     88          *z += C[i][j]*X;
     89          X = X * (*x);
     90        }
     91        Y = Y * (*y);
     92      }
     93    }
     94  }
     95  if ((xvec[0].type == OPIHI_INT) && (yvec[0].type == OPIHI_INT)) {
     96    opihi_int *x = xvec[0].elements.Int;
     97    opihi_int *y = yvec[0].elements.Int;
     98    for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {
     99      Y = X = 1;
     100      for (j = 0; j < order + 1; j++) {
     101        X = Y;
     102        for (i = 0; i < order + 1 - j; i++) {
     103          *z += C[i][j]*X;
     104          X = X * (*x);
     105        }
     106        Y = Y * (*y);
     107      }
     108    }
     109  }
     110
    65111  for (i = 0; i < order + 1; i++) free (C[i]);
    66112  free (C);

  • trunk/Ohana/src/opihi/cmd.data/concat.c

    r8131 r20936  
    55  int  i, j, Nin;
    66  double value;
     7  opihi_flt *temp;
    78  Vector *ivec, *ovec;
    89
    … …  
    1920    Nin = ovec[0].Nelements;
    2021    ovec[0].Nelements++;
    21     REALLOCATE (ovec[0].elements, float, ovec[0].Nelements);
    22     ovec[0].elements[Nin] = value;
     22    if (ovec[0].type == OPIHI_FLT) {
     23      REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements);
     24      ovec[0].elements.Flt[Nin] = value;
     25    } else {
     26      REALLOCATE (ovec[0].elements.Int, opihi_int, ovec[0].Nelements);
     27      ovec[0].elements.Int[Nin] = value;
     28    }
    2329    return (TRUE);
    2430  }
    … …  
    2632  if ((ivec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2733 
    28   REALLOCATE (ovec[0].elements, float, ovec[0].Nelements + ivec[0].Nelements);
    29   for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
    30     ovec[0].elements[j] = ivec[0].elements[i];
     34  // we have 4 cases: (ivec == flt or int) and (ovec == flt or int)
     35  if ((ovec[0].type == OPIHI_FLT) && (ivec[0].type == OPIHI_FLT)) {
     36    REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
     37    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     38      ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
     39    }
    3140  }
     41  if ((ovec[0].type == OPIHI_FLT) && (ivec[0].type == OPIHI_INT)) {
     42    REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
     43    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     44      ovec[0].elements.Flt[j] = ivec[0].elements.Int[i];
     45    }
     46  }
     47  if ((ovec[0].type == OPIHI_INT) && (ivec[0].type == OPIHI_INT)) {
     48    REALLOCATE (ovec[0].elements.Int, opihi_int, ovec[0].Nelements + ivec[0].Nelements);
     49    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     50      ovec[0].elements.Int[j] = ivec[0].elements.Int[i];
     51    }
     52  }
     53
     54  // this case forces ovec to be raised to FLT
     55  if ((ovec[0].type == OPIHI_INT) && (ivec[0].type == OPIHI_FLT)) {
     56    ALLOCATE (temp, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
     57    for (i = 0; i < ovec[0].Nelements; i++) {
     58      temp[i] = ovec[0].elements.Int[i];
     59    }
     60    ovec[0].type = OPIHI_FLT;
     61    free (ovec[0].elements.Int);
     62    ovec[0].elements.Flt = temp;
     63    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     64      ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
     65    }
     66  }
     67
    3268  ovec[0].Nelements += ivec[0].Nelements;
    33  
    3469  return (TRUE);
    35    
    3670}

  • trunk/Ohana/src/opihi/cmd.data/contour.c

    r7917 r20936  
    4444int N, NVEC;
    4545
    46 void DUMP (float x, float y, float dx, float dy) {
    47  
    48   xv[0].elements[N]   = x;
    49   xv[0].elements[N+1] = x+dx;
    50  
    51   yv[0].elements[N]   = y;
    52   yv[0].elements[N+1] = y+dy;
     46void DUMP (opihi_flt x, opihi_flt y, opihi_flt dx, opihi_flt dy) {
     47 
     48  xv[0].elements.Flt[N]   = x;
     49  xv[0].elements.Flt[N+1] = x+dx;
     50  yv[0].elements.Flt[N]   = y;
     51  yv[0].elements.Flt[N+1] = y+dy;
    5352 
    5453  N+=2;
    … …  
    5655  if (N >= NVEC - 2) {
    5756    NVEC += 100;
    58     REALLOCATE (xv[0].elements, float, NVEC);
    59     REALLOCATE (yv[0].elements, float, NVEC);
     57    REALLOCATE (xv[0].elements.Flt, opihi_flt, NVEC);
     58    REALLOCATE (yv[0].elements.Flt, opihi_flt, NVEC);
    6059  }
    6160}
    … …  
    6463
    6564  int i, j, Nx, Ny;
     65  opihi_flt x, y, dx, dy;
    6666  float level, d00, d01, d10, d11, tmp;
    67   float x, y, dx, dy;
    6867  float *v00, *v01, *v10, *v11;
    6968  float *matrix;
    … …  
    9392  N = 0;
    9493  NVEC = 100;
    95   REALLOCATE (xv[0].elements, float, NVEC);
    96   REALLOCATE (yv[0].elements, float, NVEC);
     94  ResetVector (xv, OPIHI_FLT, NVEC);
     95  ResetVector (yv, OPIHI_FLT, NVEC);
    9796
    9897  for (j = 1; j < Ny; j++) {

  • trunk/Ohana/src/opihi/cmd.data/create.c

    r12332 r20936  
    33int create (int argc, char **argv) {
    44 
    5   int i;
     5  int i, N, INT;
    66  float start, end, delta;
    77  Vector *vec;
    88 
     9  INT = FALSE;
     10  if ((N = get_argument (argc, argv, "-int"))) {
     11    INT = TRUE;
     12    remove_argument (N, &argc, argv);
     13  }
     14
    915  if ((argc != 5) && (argc != 4)) {
    1016    gprint (GP_ERR, "USAGE: create vector start end [delta]\n");
    … …  
    2733  }
    2834
     35  if (INT && (delta != (int)delta)) {
     36    gprint (GP_ERR, "integer vector requested but fractional step-size specified\n");
     37    return (FALSE);
     38  }
     39
    2940  vec[0].Nelements = (end - start) / delta;
    30   REALLOCATE (vec[0].elements, float, vec[0].Nelements);
    3141
    32   for (i = 0; i < vec[0].Nelements; i++) {
    33     vec[0].elements[i] = start + i*delta;
     42  if (INT) {
     43    vec[0].type = OPIHI_INT;
     44    REALLOCATE (vec[0].elements.Int, opihi_int, vec[0].Nelements);
     45    for (i = 0; i < vec[0].Nelements; i++) {
     46      vec[0].elements.Int[i] = start + i*delta;
     47    }
     48  } else {
     49    vec[0].type = OPIHI_FLT;
     50    REALLOCATE (vec[0].elements.Flt, opihi_flt, vec[0].Nelements);
     51    for (i = 0; i < vec[0].Nelements; i++) {
     52      vec[0].elements.Flt[i] = start + i*delta;
     53    }
    3454  }
    3555

  • trunk/Ohana/src/opihi/cmd.data/cumulative.c

    r10307 r20936  
    44 
    55  int i;
    6   float *Vi, *Vo;
     6  opihi_flt *Vo;
    77  Vector *ivec, *ovec;
    88
    … …  
    1414  if ((ivec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    1515  if ((ovec = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    16   ovec[0].Nelements = ivec[0].Nelements;
    17    
    18   REALLOCATE (ovec[0].elements, float, ovec[0].Nelements);
    19   bzero (ovec[0].elements, sizeof(float)*ovec[0].Nelements);
    2016
    21   Vi = ivec[0].elements;
    22   Vo = ovec[0].elements;
    23   *Vo = *Vi;
    24   for (i = 1; i < ivec[0].Nelements; i++, Vi++, Vo++) {
    25     *Vo = Vo[-1] + *Vi;
    26   }     
     17  ResetVector (ovec, OPIHI_FLT, ivec[0].Nelements);
     18  bzero (ovec[0].elements.Flt, sizeof(opihi_flt)*ovec[0].Nelements);
     19
     20  Vo = ovec[0].elements.Flt;
     21
     22  if (ivec[0].type == OPIHI_FLT) {
     23    opihi_flt *Vi = ivec[0].elements.Flt;
     24    *Vo = *Vi;
     25    for (i = 1; i < ivec[0].Nelements; i++, Vi++, Vo++) {
     26      *Vo = Vo[-1] + *Vi;
     27    }     
     28  } else {
     29    opihi_int *Vi = ivec[0].elements.Int;
     30    *Vo = *Vi;
     31    for (i = 1; i < ivec[0].Nelements; i++, Vi++, Vo++) {
     32      *Vo = Vo[-1] + *Vi;
     33    }     
     34  }
    2735  return (TRUE);
    2836}

  • trunk/Ohana/src/opihi/cmd.data/cut.c

    r16446 r20936  
    4848  case 'X':
    4949    /* create output vectors */
    50     xvec[0].Nelements = yvec[0].Nelements = nx;
    51     REALLOCATE (xvec[0].elements, float, MAX (nx, 1));
    52     REALLOCATE (yvec[0].elements, float, MAX (nx, 1));
    53     bzero (yvec[0].elements, nx*sizeof(float));
     50    ResetVector (xvec, OPIHI_FLT, MAX (nx, 1));
     51    ResetVector (yvec, OPIHI_FLT, MAX (nx, 1));
     52    bzero (yvec[0].elements.Flt, nx*sizeof(opihi_flt));
    5453    for (i = 0; i < nx; i++) {
    55       xvec[0].elements[i] = i + sx;
     54      xvec[0].elements.Flt[i] = i + sx;
    5655    }
    5756    ALLOCATE (Vbuf, float, MAX (ny, 1));
    … …  
    7473        if (Mode == MEAN) { value /= ny; }
    7574      }
    76       yvec[0].elements[i] = value;
     75      yvec[0].elements.Flt[i] = value;
    7776    }
    7877    free (Vbuf);
    … …  
    8180  case 'y':
    8281  case 'Y':
    83     xvec[0].Nelements = yvec[0].Nelements = ny;
    84     REALLOCATE (xvec[0].elements, float, ny);
    85     REALLOCATE (yvec[0].elements, float, ny);
    86     bzero (yvec[0].elements, ny*sizeof(float));
     82    ResetVector (xvec, OPIHI_FLT, MAX (ny, 1));
     83    ResetVector (yvec, OPIHI_FLT, MAX (ny, 1));
     84    bzero (yvec[0].elements.Flt, ny*sizeof(opihi_flt));
    8785    for (i = 0; i < ny; i++) {
    88       xvec[0].elements[i] = i + sy;
     86      xvec[0].elements.Flt[i] = i + sy;
    8987    }
    9088    ALLOCATE (Vbuf, float, MAX (nx, 1));
    … …  
    107105        if (Mode == MEAN) { value /= nx; }
    108106      }
    109       yvec[0].elements[i] = value;
     107      yvec[0].elements.Flt[i] = value;
    110108    }
    111109    free (Vbuf);

  • trunk/Ohana/src/opihi/cmd.data/dbselect.c

    r17852 r20936  
    6767      return (FALSE);
    6868    }
    69     REALLOCATE (vec[i][0].elements, float, Nrows);
    70     vec[i][0].Nelements = Nrows;
     69    switch (fields[i].type) {
     70      case FIELD_TYPE_TINY:
     71      case FIELD_TYPE_SHORT:
     72      case FIELD_TYPE_LONG:
     73      case FIELD_TYPE_INT24:
     74      case FIELD_TYPE_LONGLONG:
     75        ResetVector (vec[i], OPIHI_INT, Nrows);
     76        break;
     77      case FIELD_TYPE_DECIMAL:
     78      case FIELD_TYPE_FLOAT:
     79      case FIELD_TYPE_DOUBLE:
     80      case FIELD_TYPE_TIME:
     81      case FIELD_TYPE_DATE:
     82      case FIELD_TYPE_DATETIME:
     83        ResetVector (vec[i], OPIHI_FLT, Nrows);
     84        break;
     85      default:
     86        ResetVector (vec[i], OPIHI_FLT, Nrows);
     87        break;
     88    }
    7189  }
    7290
    … …  
    88106          case FIELD_TYPE_INT24:
    89107          case FIELD_TYPE_LONGLONG:
     108            vec[i][0].elements.Int[j] = atol (row[i]);
     109            break;
    90110          case FIELD_TYPE_DECIMAL:
    91111          case FIELD_TYPE_FLOAT:
    92112          case FIELD_TYPE_DOUBLE:
    93             vec[i][0].elements[j] = atof (row[i]);
     113            vec[i][0].elements.Flt[j] = atof (row[i]);
    94114            break;
    95115          case FIELD_TYPE_TIME:
    … …  
    97117          case FIELD_TYPE_DATETIME:
    98118            seconds = ohana_date_to_sec (row[i]);
    99             vec[i][0].elements[j] = ohana_sec_to_mjd (seconds);
     119            vec[i][0].elements.Flt[j] = ohana_sec_to_mjd (seconds);
    100120            break;
    101121          default:
    102             vec[i][0].elements[j] = NAN;
     122            vec[i][0].elements.Flt[j] = NAN;
    103123        }
    104124      } else {
    105         vec[i][0].elements[j] = NAN;
     125        vec[i][0].elements.Flt[j] = NAN;
    106126      }
    107127    }

  • trunk/Ohana/src/opihi/cmd.data/dimendown.c

    r7917 r20936  
    66 
    77  int i, Nx, Ny, Npix, N, mode;
    8   float *in, *out;
     8  float *in;
     9  opihi_flt *out;
    910  Vector *vec;
    1011  Buffer *buf;
    … …  
    2930  Npix = Nx * Ny;
    3031
    31   vec[0].Nelements = Npix;
    32   REALLOCATE (vec[0].elements, float, Npix);
     32  ResetVector (vec, OPIHI_FLT, Npix);
    3333
    3434  in = (float *) buf[0].matrix.buffer;
    35   out = vec[0].elements;
     35  out = vec[0].elements.Flt;
    3636
    3737  switch (mode) {

  • trunk/Ohana/src/opihi/cmd.data/dimenup.c

    r9275 r20936  
    44 
    55  int i, Nx, Ny, Npix;
    6   float *in, *out;
     6  float *out;
    77  Vector *vec;
    88  Buffer *buf;
    … …  
    2929
    3030  out = (float *) buf[0].matrix.buffer;
    31   in = vec[0].elements;
    3231
    33   for (i = 0; i < Npix; i++, in++, out++) {
    34     *out = *in;
     32  if (vec[0].type == OPIHI_FLT) {
     33    opihi_flt *in = vec[0].elements.Flt;
     34    for (i = 0; i < Npix; i++, in++, out++) {
     35      *out = *in;
     36    }
     37  } else {
     38    opihi_int *in = vec[0].elements.Int;
     39    for (i = 0; i < Npix; i++, in++, out++) {
     40      *out = *in;
     41    }
    3542  }
    3643

  • trunk/Ohana/src/opihi/cmd.data/fft1d.c

    r16107 r20936  
    2525  if ((Ire = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2626 
     27  REQUIRE_VECTOR_FLT (Ire, FALSE);
     28  if (Iim) { REQUIRE_VECTOR_FLT (Iim, FALSE); }
     29
    2730  // check the input data (match lengths? binary length?)
    2831  Npix = Ire[0].Nelements;
    … …  
    4043  if ((Oim = SelectVector (argv[5], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    4144
    42   // allocate sufficient output space
    43   Ore[0].Nelements = Npix;
    44   Oim[0].Nelements = Npix;
    45   REALLOCATE (Ore[0].elements, float, Npix);
    46   REALLOCATE (Oim[0].elements, float, Npix);
     45  // allocate sufficient output space, force output to be FLT
     46  ResetVector (Ore, OPIHI_FLT, Npix);
     47  ResetVector (Oim, OPIHI_FLT, Npix);
    4748 
    4849  // copy data to output vectors (fft is done in place)
    49   memcpy (Ore[0].elements, Ire[0].elements, Npix*sizeof(float));
     50  memcpy (Ore[0].elements.Flt, Ire[0].elements.Flt, Npix*sizeof(opihi_flt));
    5051
    5152  // copy imaginary vector or create a zero vector
    5253  if (ZeroImaginary) {
    53     memset (Oim[0].elements, 0, Npix*sizeof(float));
     54    memset (Oim[0].elements.Flt, 0, Npix*sizeof(opihi_flt));
    5455  } else {
    55     memcpy (Oim[0].elements, Iim[0].elements, Npix*sizeof(float));
     56    memcpy (Oim[0].elements.Flt, Iim[0].elements.Flt, Npix*sizeof(opihi_flt));
    5657  }   
    5758
    58   fft1D (Ore[0].elements, Oim[0].elements, Npix, Nbit, forward);
     59  dfft1D (Ore[0].elements.Flt, Oim[0].elements.Flt, Npix, Nbit, forward);
    5960 
    6061  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/fit.c

    r16059 r20936  
    88  int N, Weight, Quiet, ClipNiter;
    99  Vector *xvec, *yvec, *dyvec;
    10   float *x, *y, *dy, *yf, *yfit;
     10  opihi_flt *x, *y, *dy, *yf, *yfit;
    1111  char name[64], *mask;
    1212
    … …  
    5353    return (FALSE);
    5454  }
    55   if (Weight && xvec[0].Nelements != dyvec[0].Nelements) {
    56     gprint (GP_ERR, "vectors must have same length\n");
    57     return (FALSE);
    58   }
    59  
     55  REQUIRE_VECTOR_FLT (xvec, FALSE);
     56  REQUIRE_VECTOR_FLT (yvec, FALSE);
     57
     58  if (Weight) {
     59    REQUIRE_VECTOR_FLT (dyvec, FALSE);
     60    if (xvec[0].Nelements != dyvec[0].Nelements) {
     61      gprint (GP_ERR, "vectors must have same length\n");
     62      return (FALSE);
     63    }
     64  }
     65 
     66
    6067  /* nterm is number of polynomial terms, starting at x^0 */
    6168  order = atof (argv[3]);
    … …  
    6370  mterm = 2*nterm;
    6471
    65   ALLOCATE (yfit, float, xvec[0].Nelements);
     72  ALLOCATE (yfit, opihi_flt, xvec[0].Nelements);
    6673  ALLOCATE (mask, char, xvec[0].Nelements);
    6774  memset (mask, 0, xvec[0].Nelements);
    … …  
    8895
    8996    /* perform linear fit */
    90     x = xvec[0].elements;
    91     y = yvec[0].elements;
    92     if (Weight) dy = dyvec[0].elements;
     97    x = xvec[0].elements.Flt;
     98    y = yvec[0].elements.Flt;
     99    if (Weight) dy = dyvec[0].elements.Flt;
    93100
    94101    for (i = 0; i < xvec[0].Nelements; i++, x++, y++) {
    … …  
    121128
    122129    /* generate fitted values */
    123     x = xvec[0].elements;
     130    x = xvec[0].elements.Flt;
    124131    yf = yfit;
    125132    for (i = 0; i < xvec[0].Nelements; i++, x++, yf++) {
    … …  
    134141
    135142    /* measure fit residual scatter */
    136     x  = xvec[0].elements;
    137     y  = yvec[0].elements;
     143    x  = xvec[0].elements.Flt;
     144    y  = yvec[0].elements.Flt;
    138145    yf = yfit;
    139146    dY = dY2 = 0;
    … …  
    150157
    151158    /* mask outlier points */
    152     x  = xvec[0].elements;
    153     y  = yvec[0].elements;
     159    x  = xvec[0].elements.Flt;
     160    y  = yvec[0].elements.Flt;
    154161    yf = yfit;
    155162    Nmask = 0;
    … …  
    193200    if ((fvec = SelectVector ("yfit", ANYVECTOR, TRUE)) == NULL) return (FALSE);   
    194201    if ((mvec = SelectVector ("mask", ANYVECTOR, TRUE)) == NULL) return (FALSE);   
    195     free (fvec[0].elements);
    196     fvec[0].elements = yfit;
     202    free (fvec[0].elements.Flt);
     203    fvec[0].elements.Flt = yfit;
    197204    fvec[0].Nelements = xvec[0].Nelements;
    198205    mvec[0].Nelements = xvec[0].Nelements;
    199206
    200     REALLOCATE (mvec[0].elements, float, xvec[0].Nelements);
     207    REALLOCATE (mvec[0].elements.Flt, opihi_flt, xvec[0].Nelements);
    201208    for (i = 0; i < xvec[0].Nelements; i++) {
    202       mvec[0].elements[i] = mask[i];
     209      mvec[0].elements.Flt[i] = mask[i];
    203210    }
    204211  } else {

  • trunk/Ohana/src/opihi/cmd.data/fit2d.c

    r16059 r20936  
    77  int k, K, i, j, n, Npt, Nmask, nx, ny, nterm, mterm, wterm, order;
    88  int N, Weight, Quiet, ClipNiter, VERBOSE;
    9   float *x, *y, *z, *dz, *zfit, *zf;
     9  opihi_flt *x, *y, *z, *dz, *zfit, *zf;
    1010  char name[64], *mask;
    1111  Vector *xvec, *yvec, *zvec, *dzvec;
    … …  
    6464    return (FALSE);
    6565  }
    66   if (Weight && xvec[0].Nelements != dzvec[0].Nelements) {
    67     gprint (GP_ERR, "vectors must have same length\n");
    68     return (FALSE);
     66  REQUIRE_VECTOR_FLT (xvec, FALSE);
     67  REQUIRE_VECTOR_FLT (yvec, FALSE);
     68  REQUIRE_VECTOR_FLT (zvec, FALSE);
     69
     70  if (Weight) {
     71    REQUIRE_VECTOR_FLT (dzvec, FALSE);
     72    if (xvec[0].Nelements != dzvec[0].Nelements) {
     73      gprint (GP_ERR, "vectors must have same length\n");
     74      return (FALSE);
     75    }
    6976  }
    7077 
    … …  
    7481  mterm = 2*order + 1;
    7582
    76   ALLOCATE (zfit, float, xvec[0].Nelements);
     83  ALLOCATE (zfit, opihi_flt, xvec[0].Nelements);
    7784  ALLOCATE (mask, char, xvec[0].Nelements);
    7885  memset (mask, 0, xvec[0].Nelements);
    … …  
    102109    }
    103110
    104     x = xvec[0].elements;
    105     y = yvec[0].elements;
    106     z = zvec[0].elements;
    107     if (Weight) dz = dzvec[0].elements;
     111    x = xvec[0].elements.Flt;
     112    y = yvec[0].elements.Flt;
     113    z = zvec[0].elements.Flt;
     114    if (Weight) dz = dzvec[0].elements.Flt;
    108115
    109116    /* add up the x,y values */
    … …  
    128135
    129136    /* add up the z values */
    130     x = xvec[0].elements;
    131     y = yvec[0].elements;
    132     z = zvec[0].elements;
     137    x = xvec[0].elements.Flt;
     138    y = yvec[0].elements.Flt;
     139    z = zvec[0].elements.Flt;
    133140    for (i = 0; i < xvec[0].Nelements; i++, x++, y++, z++) {
    134141      if (mask[i]) continue;
    … …  
    179186    */
    180187    /* generate fitted values */
    181     x = xvec[0].elements;
    182     y = yvec[0].elements;
     188    x = xvec[0].elements.Flt;
     189    y = yvec[0].elements.Flt;
    183190    zf = zfit;
    184191    for (n = 0; n < xvec[0].Nelements; n++, x++, y++, zf++) {
    … …  
    197204
    198205    /* measure fit residual scatter */
    199     x  = xvec[0].elements;
    200     y  = yvec[0].elements;
    201     z  = zvec[0].elements;
     206    x  = xvec[0].elements.Flt;
     207    y  = yvec[0].elements.Flt;
     208    z  = zvec[0].elements.Flt;
    202209    zf = zfit;
    203210    dZ = dZ2 = 0;
    … …  
    216223
    217224    /* mask outlier points */
    218     x  = xvec[0].elements;
    219     y  = yvec[0].elements;
    220     z  = zvec[0].elements;
     225    x  = xvec[0].elements.Flt;
     226    y  = yvec[0].elements.Flt;
     227    z  = zvec[0].elements.Flt;
    221228    zf = zfit;
    222229    Nmask = 0;

  • trunk/Ohana/src/opihi/cmd.data/gaussdeviate.c

    r7917 r20936  
    1515  sigma = atof (argv[4]);
    1616
    17   vec[0].Nelements = Npts;
    18   REALLOCATE (vec[0].elements, float, Npts);
     17  ResetVector (vec, OPIHI_FLT, Npts);
    1918
    2019  gauss_init (2048);
    2120  for (i = 0; i < Npts; i++) {
    22     vec[0].elements[i] = rnd_gauss (mean, sigma);
     21    vec[0].elements.Flt[i] = rnd_gauss (mean, sigma);
    2322  }
    2423  return (TRUE);
    … …  
    4645  sigma = atof (argv[4]);
    4746
    48   vec[0].Nelements = Npts;
    49   REALLOCATE (vec[0].elements, float, Npts);
     47  ResetVector (vec, OPIHI_FLT, Npts);
    5048
    5149  gauss_init (Npts);
    5250  for (i = 0; i < Npts; i++) {
    53     vec[0].elements[i] = int_gauss (i);
     51    vec[0].elements.Flt[i] = int_gauss (i);
    5452  }
    5553  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/gaussj.c

    r16117 r20936  
    22
    33int gaussjordan (int argc, char **argv) {
    4  
    5   float *m, *v;
     4
     5  float *m;
     6  opihi_flt *vf;
     7  opihi_int *vi;
    68  double **a, **b;
    7   int i, j, N, status, QUIET;
     9  int i, j, N, status, QUIET, isFloat;
    810  Vector *B;
    911  Buffer *A;
    … …  
    3133  }
    3234
     35  isFloat = (B[0].type == OPIHI_FLT);
     36  vf = B[0].elements.Flt;
     37  vi = B[0].elements.Int;
     38
    3339  m = (float *) A[0].matrix.buffer;
    34   v = B[0].elements;
    3540  for (i = 0; i < N; i++) {
    3641    for (j = 0; j < N; j++) {
    3742      a[i][j] = m[i+j*N];
    3843    }
    39     b[i][0] = v[i];
     44    b[i][0] = isFloat ? vf[i] : vi[i];
    4045  }
    4146
    4247  status = dgaussjordan (a, b, N, 1);
     48
     49  // output vector needs to be float, so re-cast it
     50  ResetVector (B, OPIHI_FLT, N);
     51  vf = B[0].elements.Flt;
    4352
    4453  for (i = 0; i < N; i++) {
    … …  
    4655       m[i+j*N] = a[i][j];
    4756    }
    48     v[i] = b[i][0];
     57    vf[i] = b[i][0];
    4958  }
    5059

  • trunk/Ohana/src/opihi/cmd.data/grid.c

    r13479 r20936  
    2323
    2424  N = 0;
    25   Xvec.Nelements = 200;
    26   Yvec.Nelements = 200;
    27   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    28   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
     25  SetVector (&Xvec, OPIHI_FLT, 200);
     26  SetVector (&Yvec, OPIHI_FLT, 200);
    2927
    3028  major = minor = 1;
    … …  
    6462      if (MajorTick) {
    6563        /* major tick */
    66         Xvec.elements[N] = next;
    67         Yvec.elements[N] = graphmode.ymin;
    68         N++;
    69         if (N == Xvec.Nelements) {
    70           Xvec.Nelements += 200;
    71           Yvec.Nelements += 200;
    72           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    73           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
    74         }
    75         Xvec.elements[N] = next;
    76         Yvec.elements[N] = graphmode.ymax;
    77         N++;
    78         if (N == Xvec.Nelements) {
    79           Xvec.Nelements += 200;
    80           Yvec.Nelements += 200;
    81           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    82           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
     64        Xvec.elements.Flt[N] = next;
     65        Yvec.elements.Flt[N] = graphmode.ymin;
     66        N++;
     67        if (N == Xvec.Nelements) {
     68          Xvec.Nelements += 200;
     69          Yvec.Nelements += 200;
     70          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     71          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     72        }
     73        Xvec.elements.Flt[N] = next;
     74        Yvec.elements.Flt[N] = graphmode.ymax;
     75        N++;
     76        if (N == Xvec.Nelements) {
     77          Xvec.Nelements += 200;
     78          Yvec.Nelements += 200;
     79          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     80          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    8381        }
    8482      }
    … …  
    8684      if (MinorTick) {
    8785        /* minor tick */
    88         Xvec.elements[N] = next;
    89         Yvec.elements[N] = graphmode.ymin;
    90         N++;
    91         if (N == Xvec.Nelements) {
    92           Xvec.Nelements += 200;
    93           Yvec.Nelements += 200;
    94           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    95           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
    96         }
    97         Xvec.elements[N] = next;
    98         Yvec.elements[N] = graphmode.ymax;
    99         N++;
    100         if (N == Xvec.Nelements) {
    101           Xvec.Nelements += 200;
    102           Yvec.Nelements += 200;
    103           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    104           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
     86        Xvec.elements.Flt[N] = next;
     87        Yvec.elements.Flt[N] = graphmode.ymin;
     88        N++;
     89        if (N == Xvec.Nelements) {
     90          Xvec.Nelements += 200;
     91          Yvec.Nelements += 200;
     92          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     93          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     94        }
     95        Xvec.elements.Flt[N] = next;
     96        Yvec.elements.Flt[N] = graphmode.ymax;
     97        N++;
     98        if (N == Xvec.Nelements) {
     99          Xvec.Nelements += 200;
     100          Yvec.Nelements += 200;
     101          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     102          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    105103        }
    106104      }
    … …  
    144142      if (MajorTick) {
    145143        /* major tick */
    146         Xvec.elements[N] = graphmode.xmin;
    147         Yvec.elements[N] = next;
    148         N++;
    149         if (N == Xvec.Nelements) {
    150           Xvec.Nelements += 200;
    151           Yvec.Nelements += 200;
    152           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    153           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
    154         }
    155         Xvec.elements[N] = graphmode.xmax;
    156         Yvec.elements[N] = next;
    157         N++;
    158         if (N == Xvec.Nelements) {
    159           Xvec.Nelements += 200;
    160           Yvec.Nelements += 200;
    161           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    162           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
     144        Xvec.elements.Flt[N] = graphmode.xmin;
     145        Yvec.elements.Flt[N] = next;
     146        N++;
     147        if (N == Xvec.Nelements) {
     148          Xvec.Nelements += 200;
     149          Yvec.Nelements += 200;
     150          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     151          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     152        }
     153        Xvec.elements.Flt[N] = graphmode.xmax;
     154        Yvec.elements.Flt[N] = next;
     155        N++;
     156        if (N == Xvec.Nelements) {
     157          Xvec.Nelements += 200;
     158          Yvec.Nelements += 200;
     159          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     160          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    163161        }
    164162      }
    … …  
    166164      if (MinorTick) {
    167165        /* minor tick */
    168         Xvec.elements[N] = graphmode.xmin;
    169         Yvec.elements[N] = next;
    170         N++;
    171         if (N == Xvec.Nelements) {
    172           Xvec.Nelements += 200;
    173           Yvec.Nelements += 200;
    174           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    175           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
    176         }
    177         Xvec.elements[N] = graphmode.xmax;
    178         Yvec.elements[N] = next;
    179         N++;
    180         if (N == Xvec.Nelements) {
    181           Xvec.Nelements += 200;
    182           Yvec.Nelements += 200;
    183           REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    184           REALLOCATE (Yvec.elements, float, Yvec.Nelements);
     166        Xvec.elements.Flt[N] = graphmode.xmin;
     167        Yvec.elements.Flt[N] = next;
     168        N++;
     169        if (N == Xvec.Nelements) {
     170          Xvec.Nelements += 200;
     171          Yvec.Nelements += 200;
     172          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     173          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     174        }
     175        Xvec.elements.Flt[N] = graphmode.xmax;
     176        Yvec.elements.Flt[N] = next;
     177        N++;
     178        if (N == Xvec.Nelements) {
     179          Xvec.Nelements += 200;
     180          Yvec.Nelements += 200;
     181          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     182          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    185183        }
    186184      }
    … …  
    193191  graphmode.ptype = 100; /* connect a pair */
    194192  graphmode.etype = 0;
    195   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
    196 
    197   free (Xvec.elements);
    198   free (Yvec.elements);
     193  PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
     194
     195  free (Xvec.elements.Flt);
     196  free (Yvec.elements.Flt);
    199197
    200198  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/gridify.c

    r9275 r20936  
    55  int i, Nx, Ny, Xb, Yb, Normalize, N;
    66  float Xmin, Xmax, dX, Ymin, Ymax, dY;
    7   float *buf, *val, *x, *y, *z;
     7  float *buf, *val;
    88  int *Nval;
    99  Buffer *bf;
    1010  Vector *vx, *vy, *vz;
     11  opihi_flt *x, *y, *z;
    1112
    1213  Normalize = TRUE;
    … …  
    2829  if (vx[0].Nelements != vy[0].Nelements) return (FALSE);
    2930  if (vx[0].Nelements != vz[0].Nelements) return (FALSE);
     31
     32  REQUIRE_VECTOR_FLT (vx, FALSE);
     33  REQUIRE_VECTOR_FLT (vy, FALSE);
     34  REQUIRE_VECTOR_FLT (vz, FALSE);
    3035
    3136  Xmin = atof (argv[5]);
    … …  
    5055  bzero (Nval, Nx*Ny*sizeof(int));
    5156
    52   x = vx[0].elements;
    53   y = vy[0].elements;
    54   z = vz[0].elements;
     57  x = vx[0].elements.Flt;
     58  y = vy[0].elements.Flt;
     59  z = vz[0].elements.Flt;
    5560  for (i = 0; i < vx[0].Nelements; i++, x++, y++, z++) {
    5661    Xb = (*x - Xmin) / dX;

  • trunk/Ohana/src/opihi/cmd.data/histogram.c

    r18251 r20936  
    44 
    55  int i, bin, Nbins;
    6   float *V, start, end, delta;
     6  opihi_int *OUT;
     7  opihi_flt start, end, delta;
    78  Vector *xvec, *yvec;
    89
    … …  
    3031  if ((xvec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    3132  if ((yvec = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    32   yvec[0].Nelements = Nbins;
    33    
    34   REALLOCATE (yvec[0].elements, float, yvec[0].Nelements);
    35   bzero (yvec[0].elements, sizeof(float)*yvec[0].Nelements);
    36   if (Nbins < 1) {
    37       return (TRUE);
     33
     34  ResetVector (yvec, OPIHI_INT, Nbins);
     35  bzero (yvec[0].elements.Int, sizeof(opihi_int)*yvec[0].Nelements);
     36  if (Nbins < 1) return (TRUE);
     37  OUT = yvec[0].elements.Int;
     38
     39  if (xvec[0].type == OPIHI_FLT) {
     40    opihi_flt *V = xvec[0].elements.Flt;
     41    for (i = 0; i < xvec[0].Nelements; i++, V++) {
     42      if (isnan(*V)) continue;
     43      bin = MIN (MAX (0, (*V - start) / delta), Nbins - 1);
     44      OUT[bin]++;
     45    }     
     46  } else {
     47    opihi_int *V = xvec[0].elements.Int;
     48    for (i = 0; i < xvec[0].Nelements; i++, V++) {
     49      if (isnan(*V)) continue;
     50      bin = MIN (MAX (0, (*V - start) / delta), Nbins - 1);
     51      OUT[bin]++;
     52    }     
    3853  }
    39 
    40   V = xvec[0].elements;
    41   for (i = 0; i < xvec[0].Nelements; i++, V++) {
    42     if (isnan(*V)) continue;
    43     bin = MIN (MAX (0, (*V - start) / delta), Nbins - 1);
    44     yvec[0].elements[bin] += 1.0;
    45   }     
    4654
    4755  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/imcut.c

    r7917 r20936  
    3737  dY = dY / L;
    3838
    39   REALLOCATE (xvec[0].elements, float, MAX (L, 1));
    40   REALLOCATE (yvec[0].elements, float, MAX (L, 1));
    41   xvec[0].Nelements = L;
    42   yvec[0].Nelements = L;
     39  ResetVector (xvec, OPIHI_FLT, MAX (L, 1));
     40  ResetVector (yvec, OPIHI_FLT, MAX (L, 1));
    4341
    4442  V = (float *)buf[0].matrix.buffer;
    … …  
    4644    xi = xs + i*dX - 0.5;
    4745    yi = ys + i*dY - 0.5;
    48     xvec[0].elements[i] = i;
    49     yvec[0].elements[i] = V[xi + Nx*yi];
     46    xvec[0].elements.Flt[i] = i;
     47    yvec[0].elements.Flt[i] = V[xi + Nx*yi];
    5048  }
    5149

  • trunk/Ohana/src/opihi/cmd.data/imhist.c

    r16429 r20936  
    105105  } 
    106106
    107   vec1[0].Nelements = Nbins + 1;
    108   vec2[0].Nelements = Nbins + 1;
    109   REALLOCATE (vec1[0].elements, float, vec1[0].Nelements);
    110   bzero (vec1[0].elements, vec1[0].Nelements*sizeof(float));
    111   REALLOCATE (vec2[0].elements, float, vec2[0].Nelements);
    112   bzero (vec2[0].elements, vec2[0].Nelements*sizeof(float));
     107  ResetVector (vec1, OPIHI_FLT, Nbins + 1);
     108  ResetVector (vec2, OPIHI_FLT, Nbins + 1);
     109  bzero (vec1[0].elements.Flt, vec1[0].Nelements*sizeof(opihi_flt));
     110  bzero (vec2[0].elements.Flt, vec2[0].Nelements*sizeof(opihi_flt));
    113111 
    114112  for (j = sy; j < sy + ny; j++) {
    … …  
    116114    for (i = 0; i < nx; i++, V++) {
    117115      bin = MAX (MIN (Nbins, (*V - min) / dx), 0);
    118       vec2[0].elements[bin] += 1.0;
     116      vec2[0].elements.Flt[bin] += 1.0;
    119117    }
    120118  }
    121119  for (i = 0; i < Nbins + 1; i++, V++) {
    122     vec1[0].elements[i] = i*dx + min;
     120    vec1[0].elements.Flt[i] = i*dx + min;
    123121  }
    124122 

  • trunk/Ohana/src/opihi/cmd.data/integrate.c

    r7917 r20936  
    33int integrate (int argc, char **argv) {
    44 
    5   int i, N, VERBOSE;
    6   float *X, *Y;
    7   double start, end, value, range;
     5  int i, N, VERBOSE, isFloat;
     6  opihi_flt *Yf;
     7  opihi_int *Yi;
     8  double start, end, value, range, dvalue;
    89  Vector *vecx, *vecy;
    910
    … …  
    2526  end   = atof (argv[4]);
    2627
    27   X = vecx[0].elements;
    28   Y = vecy[0].elements;
     28  isFloat = vecy[0].type == OPIHI_FLT;
     29  Yf = vecy[0].elements.Flt;
     30  Yi = vecy[0].elements.Int;
    2931
    3032  value = 0;
    3133  range = 0;
    32   for (i = 0; i < vecx[0].Nelements-1; i++, X++, Y++) {
    33     if ((*X >= start) && (*X <= end)) {
    34       value += *Y * (X[1] - X[0]);
    35       range += (X[1] - X[0]);
    36     }
    37   }     
     34
     35  if (vecx[0].type == OPIHI_FLT) {
     36    opihi_flt *X = vecx[0].elements.Flt;
     37    for (i = 0; i < vecx[0].Nelements-1; i++, X++, Yi++, Yf++) {
     38      if ((*X >= start) && (*X <= end)) {
     39        dvalue = (isFloat) ? *Yf : *Yi;
     40        value += dvalue * (X[1] - X[0]);
     41        range += (X[1] - X[0]);
     42      }
     43    }     
     44  } else {
     45    opihi_int *X = vecx[0].elements.Int;
     46    for (i = 0; i < vecx[0].Nelements-1; i++, X++, Yi++, Yf++) {
     47      if ((*X >= start) && (*X <= end)) {
     48        dvalue = (isFloat) ? *Yf : *Yi;
     49        value += dvalue * (X[1] - X[0]);
     50        range += (X[1] - X[0]);
     51      }
     52    }     
     53  }
    3854
    3955  set_variable ("sum", value);

  • trunk/Ohana/src/opihi/cmd.data/interpolate.c

    r7917 r20936  
    2121  if ((yout = SelectVector (argv[4],  ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2222
    23   yout[0].Nelements = xout[0].Nelements;
    24   REALLOCATE (yout[0].elements, float, yout[0].Nelements);
     23  REQUIRE_VECTOR_FLT (xin, FALSE);
     24  REQUIRE_VECTOR_FLT (yin, FALSE);
     25  REQUIRE_VECTOR_FLT (xout, FALSE);
     26  ResetVector (yout, OPIHI_FLT, xout[0].Nelements);
    2527
    26   dx = xin[0].elements[1] - xin[0].elements[0];
    27   dy = yin[0].elements[1] - yin[0].elements[0];
    28   x0 = xin[0].elements[0];
    29   y0 = yin[0].elements[0];
     28  dx = xin[0].elements.Flt[1] - xin[0].elements.Flt[0];
     29  dy = yin[0].elements.Flt[1] - yin[0].elements.Flt[0];
     30  x0 = xin[0].elements.Flt[0];
     31  y0 = yin[0].elements.Flt[0];
    3032 
    3133  /* in vectors are sorted, out vectors are not */
    3234  for (j = 0; j < xin[0].Nelements - 1; j++) {
    33     dx = xin[0].elements[j+1] - xin[0].elements[j];
    34     dy = yin[0].elements[j+1] - yin[0].elements[j];
    35     x0 = xin[0].elements[j];
    36     y0 = yin[0].elements[j];
    37     x1 = xin[0].elements[j+1];
     35    dx = xin[0].elements.Flt[j+1] - xin[0].elements.Flt[j];
     36    dy = yin[0].elements.Flt[j+1] - yin[0].elements.Flt[j];
     37    x0 = xin[0].elements.Flt[j];
     38    y0 = yin[0].elements.Flt[j];
     39    x1 = xin[0].elements.Flt[j+1];
    3840    for (i = 0; i < xout[0].Nelements; i++) {
    39       if ((xout[0].elements[i] >= x0) && (xout[0].elements[i] < x1)) {
    40         yout[0].elements[i] = (dy/dx)*(xout[0].elements[i] - x0) + y0;
     41      if ((xout[0].elements.Flt[i] >= x0) && (xout[0].elements.Flt[i] < x1)) {
     42        yout[0].elements.Flt[i] = (dy/dx)*(xout[0].elements.Flt[i] - x0) + y0;
    4143      }
    42       if ((j == 0) && (xout[0].elements[i] < x0)) {
    43         yout[0].elements[i] = (dy/dx)*(xout[0].elements[i] - x0) + y0;
     44      if ((j == 0) && (xout[0].elements.Flt[i] < x0)) {
     45        yout[0].elements.Flt[i] = (dy/dx)*(xout[0].elements.Flt[i] - x0) + y0;
    4446      }
    45       if ((j == xin[0].Nelements - 2) && (xout[0].elements[i] >= x1)) {
    46         yout[0].elements[i] = (dy/dx)*(xout[0].elements[i] - x0) + y0;
     47      if ((j == xin[0].Nelements - 2) && (xout[0].elements.Flt[i] >= x1)) {
     48        yout[0].elements.Flt[i] = (dy/dx)*(xout[0].elements.Flt[i] - x0) + y0;
    4749      }
    4850    }   

  • trunk/Ohana/src/opihi/cmd.data/lookup.c

    r7952 r20936  
    44 
    55  int i, j;
    6   float *ip, *op, *xp, *yp;
     6  opihi_flt *ip, *op, *xp, *yp;
    77  Vector *in, *out, *xv, *yv;
    88
    … …  
    1717  if ((yv  = SelectVector (argv[4], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    1818
     19  REQUIRE_VECTOR_FLT (in, FALSE);
     20  REQUIRE_VECTOR_FLT (xv, FALSE);
     21  REQUIRE_VECTOR_FLT (yv, FALSE);
     22
    1923  if (xv[0].Nelements != yv[0].Nelements) {
    2024      gprint (GP_ERR, "unmatched lookup table lengths\n");
    … …  
    2226  }
    2327
    24   out[0].Nelements = in[0].Nelements;
    25   REALLOCATE (out[0].elements, float, out[0].Nelements);
     28  ResetVector (out, OPIHI_FLT, in[0].Nelements);
    2629
    27   ip = in[0].elements;
    28   op = out[0].elements;
     30  ip = in[0].elements.Flt;
     31  op = out[0].elements.Flt;
    2932
    3033  for (i = 0; i < in[0].Nelements; i++, ip++, op++) {
    3134    // re-write this using bisection
    32     xp = xv[0].elements;
    33     yp = yv[0].elements;
     35    xp = xv[0].elements.Flt;
     36    yp = yv[0].elements.Flt;
    3437
    3538    for (j = 0; (*ip < *xp) && (j < yv[0].Nelements); j++);

  • trunk/Ohana/src/opihi/cmd.data/medacc.c

    r7917 r20936  
    55  int i, j, Nbins, Nvalues, N, N0, N1;
    66  double start, end, delta, k0, k1, fn;
    7   float *V, *K, *V1, *K1, *O, *tmpvec, *tmpkey;
     7  opihi_flt *V, *K, *V1, *K1, *O, *tmpvec, *tmpkey;
    88  Vector *val, *key, *out;
    99
    … …  
    2121  if ((out = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2222
     23  REQUIRE_VECTOR_FLT (val, FALSE);
     24  REQUIRE_VECTOR_FLT (key, FALSE);
     25
    2326  start = atof (argv[4]);
    2427  end   = atof (argv[5]);
    … …  
    3437  Nbins = 1 + (int)((end - start) / delta);
    3538
    36   out[0].Nelements = Nbins;
    37   REALLOCATE (out[0].elements, float, out[0].Nelements);
    38   bzero (out[0].elements, sizeof(float)*out[0].Nelements);
     39  ResetVector (out, OPIHI_FLT, Nbins);
     40  bzero (out[0].elements.Flt, sizeof(opihi_flt)*out[0].Nelements);
    3941
    4042  /* copy vec and key to temp vectors */
    41   ALLOCATE (tmpvec, float, val[0].Nelements);
    42   ALLOCATE (tmpkey, float, val[0].Nelements);
     43  ALLOCATE (tmpvec, opihi_flt, val[0].Nelements);
     44  ALLOCATE (tmpkey, opihi_flt, val[0].Nelements);
    4345
    44   V = val[0].elements;
    45   K = key[0].elements;
     46  V = val[0].elements.Flt;
     47  K = key[0].elements.Flt;
    4648  V1 = tmpvec;
    4749  K1 = tmpkey;
    … …  
    5355
    5456  /* sort vec and key by key */
    55   fsortpair (tmpkey, tmpvec, Nvalues);
     57  dsortpair (tmpkey, tmpvec, Nvalues);
    5658
    57   O = out[0].elements;
     59  O = out[0].elements.Flt;
    5860  /* find the start and end key for each range */
    5961  N0 = 0;
    … …  
    6769    N1 = j;
    6870    N = N1 - N0;
    69     fsort (&tmpvec[N0], N);
     71    dsort (&tmpvec[N0], N);
    7072    fn = O[i] = 0;
    7173    for (j = N0 + 0.25*N; j < N0 + 0.75*N; j++) {

  • trunk/Ohana/src/opihi/cmd.data/mget.c

    r7917 r20936  
    44 
    55  int i, Nx, Ny, Npix, xdir, Nset;
    6   float *in, *out;
     6  float *in;
     7  opihi_flt *out;
    78  Buffer *buf;
    89  Vector *vec;
    … …  
    3233
    3334  if (xdir) {
    34     vec[0].Nelements = Npix = Nx;
    35     REALLOCATE (vec[0].elements, float, Npix);
     35    Npix = Nx;
     36    ResetVector (vec, OPIHI_FLT, Nx);
    3637    if (Nset >= Ny) {
    3738      gprint (GP_ERR, "row out of range\n");
    … …  
    3940    }
    4041    in  = (float *) buf[0].matrix.buffer + Nx*Nset;
    41     out = vec[0].elements;
     42    out = vec[0].elements.Flt;
    4243    for (i = 0; i < Npix; i++, in++, out++) {
    4344      *out = *in;
    4445    }
    45     return (TRUE);
    4646  } else {
    47     vec[0].Nelements = Npix = Ny;
    48     REALLOCATE (vec[0].elements, float, Npix);
     47    Npix = Ny;
     48    ResetVector (vec, OPIHI_FLT, Ny);
    4949    if (Nset >= Nx) {
    5050      gprint (GP_ERR, "column out of range\n");
    … …  
    5252    }
    5353    in  = (float *) buf[0].matrix.buffer + Nset;
    54     out = vec[0].elements;
     54    out = vec[0].elements.Flt;
    5555    for (i = 0; i < Npix; i++, in+=Nx, out++) {
    5656      *out = *in;
    5757    }
    58     return (TRUE);
    59   }   
     58  }
     59  return (TRUE);
    6060}
    61 

  • trunk/Ohana/src/opihi/cmd.data/mset.c

    r7917 r20936  
    44 
    55  int i, Nx, Ny, Npix, xdir, Nset;
    6   float *in, *out;
     6  float *out;
    77  Buffer *buf;
    88  Vector *vec;
    … …  
    4242    }
    4343    out = (float *) buf[0].matrix.buffer + Nx*Nset;
    44     in = vec[0].elements;
    45     for (i = 0; i < Npix; i++, in++, out++) {
    46       *out = *in;
     44
     45    if (vec[0].type == OPIHI_FLT) {
     46      opihi_flt *in = vec[0].elements.Flt;
     47      for (i = 0; i < Npix; i++, in++, out++) {
     48        *out = *in;
     49      }
     50    } else {
     51      opihi_int *in = vec[0].elements.Int;
     52      for (i = 0; i < Npix; i++, in++, out++) {
     53        *out = *in;
     54      }
    4755    }
    4856    return (TRUE);
     57
    4958  } else {
    5059    if (Ny != Npix) {
    … …  
    5766    }
    5867    out = (float *) buf[0].matrix.buffer + Nset;
    59     in = vec[0].elements;
    60     for (i = 0; i < Npix; i++, in++, out+=Nx) {
    61       *out = *in;
     68
     69    if (vec[0].type == OPIHI_FLT) {
     70      opihi_flt *in = vec[0].elements.Flt;
     71      for (i = 0; i < Npix; i++, in++, out+=Nx) {
     72        *out = *in;
     73      }
     74    } else {
     75      opihi_int *in = vec[0].elements.Int;
     76      for (i = 0; i < Npix; i++, in++, out+=Nx) {
     77        *out = *in;
     78      }
    6279    }
    6380    return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/peak.c

    r7917 r20936  
    55  int i, N, imax, QUIET;
    66  double start, end, xmax, ymax;
    7   float *X, *Y;
    87  Vector *vecx, *vecy;
    98
    … …  
    2625    end   = atof (argv[4]);
    2726  } else {
    28     start = vecx[0].elements[0];
    29     end   = vecx[0].elements[vecx[0].Nelements - 1];
     27    start = (vecx[0].type == OPIHI_FLT) ? vecx[0].elements.Flt[0] : vecx[0].elements.Int[0];
     28    end   = (vecx[0].type == OPIHI_FLT) ? vecx[0].elements.Flt[vecx[0].Nelements - 1] : vecx[0].elements.Int[vecx[0].Nelements - 1];
    3029  }
    3130
    32   X = vecx[0].elements;
    33   Y = vecy[0].elements;
     31  imax = -1;
     32  xmax = -HUGE_VAL;
     33  ymax = -HUGE_VAL;
    3434
    35   imax = -1;
    36   xmax = *X;
    37   ymax = *Y;
    38   for (i = 1; i < vecx[0].Nelements-1; i++, X++, Y++) {
    39     if ((*X >= start) && (*X <= end)) {
    40       if ((imax == -1) || (*Y > ymax)) {
    41         xmax = *X;
    42         ymax = *Y;
    43         imax = i;
    44       }
    45     }
    46   }     
     35  if ((vecx[0].type == OPIHI_FLT) && (vecy[0].type == OPIHI_FLT)) {
     36    opihi_flt *X = vecx[0].elements.Flt;
     37    opihi_flt *Y = vecy[0].elements.Flt;
     38    for (i = 0; i < vecx[0].Nelements; i++, X++, Y++) {
     39      if (*X < start) continue;
     40      if (*X > end) continue;
     41      if (*Y < ymax) continue;
     42      xmax = *X;
     43      ymax = *Y;
     44      imax = i;
     45    }     
     46  }
     47  if ((vecx[0].type == OPIHI_FLT) && (vecy[0].type == OPIHI_INT)) {
     48    opihi_flt *X = vecx[0].elements.Flt;
     49    opihi_int *Y = vecy[0].elements.Int;
     50    for (i = 0; i < vecx[0].Nelements; i++, X++, Y++) {
     51      if (*X < start) continue;
     52      if (*X > end) continue;
     53      if (*Y < ymax) continue;
     54      xmax = *X;
     55      ymax = *Y;
     56      imax = i;
     57    }     
     58  }
     59  if ((vecx[0].type == OPIHI_INT) && (vecy[0].type == OPIHI_FLT)) {
     60    opihi_int *X = vecx[0].elements.Int;
     61    opihi_flt *Y = vecy[0].elements.Flt;
     62    for (i = 0; i < vecx[0].Nelements; i++, X++, Y++) {
     63      if (*X < start) continue;
     64      if (*X > end) continue;
     65      if (*Y < ymax) continue;
     66      xmax = *X;
     67      ymax = *Y;
     68      imax = i;
     69    }     
     70  }
     71  if ((vecx[0].type == OPIHI_INT) && (vecy[0].type == OPIHI_INT)) {
     72    opihi_int *X = vecx[0].elements.Int;
     73    opihi_int *Y = vecy[0].elements.Int;
     74    for (i = 0; i < vecx[0].Nelements; i++, X++, Y++) {
     75      if (*X < start) continue;
     76      if (*X > end) continue;
     77      if (*Y < ymax) continue;
     78      xmax = *X;
     79      ymax = *Y;
     80      imax = i;
     81    }     
     82  }
    4783
    4884  set_variable ("peakval", ymax);

  • trunk/Ohana/src/opihi/cmd.data/periodogram.c

    r7917 r20936  
    44 
    55  int i, N, Npt, Np, NP, VERBOSE;
    6   float *tv, *fv;
     6  opihi_flt *tv, *fv;
    77  float minP, maxP, minT, maxT, dTime;
    88  float mean, var, w, tau, P, Pc, Ps, Po;
    … …  
    2828  if ((power = SelectVector (argv[6], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2929
     30  REQUIRE_VECTOR_FLT (time, FALSE);
     31  REQUIRE_VECTOR_FLT (flux, FALSE);
     32
    3033  /* find the max baseline, mean, and variance */
    31   minT = maxT = time[0].elements[0];
     34  minT = maxT = time[0].elements.Flt[0];
    3235  Npt = time[0].Nelements;
    33   tv = time[0].elements;
    34   fv = flux[0].elements;
     36  tv = time[0].elements.Flt;
     37  fv = flux[0].elements.Flt;
    3538  mean = var = 0;
    3639  for (i = 0; i < Npt; i++, tv++, fv++) {
    … …  
    4043  }
    4144  mean = mean / Npt;
    42   fv = flux[0].elements;
     45  fv = flux[0].elements.Flt;
    4346  for (i = 0; i < Npt; i++, fv++) {
    4447    var += SQ(*fv - mean);
    … …  
    5659  Np = 0;
    5760  NP = 100;
    58   REALLOCATE (power[0].elements, float, NP);
    59   REALLOCATE (period[0].elements, float, NP);
     61  ResetVector (power,  OPIHI_FLT, NP);
     62  ResetVector (period, OPIHI_FLT, NP);
    6063
    6164  P = minP;
    … …  
    6467   
    6568    /* find the period offset tau  */
    66     tv = time[0].elements;
     69    tv = time[0].elements.Flt;
    6770    cs = sn = 0;
    6871    for (i = 0; i < Npt; i++, tv++) {
    … …  
    7376     
    7477    /* find the power at this period */
    75     tv = time[0].elements;
    76     fv = flux[0].elements;
     78    tv = time[0].elements.Flt;
     79    fv = flux[0].elements.Flt;
    7780    cs = sn = cs2 = sn2 = 0;
    7881    for (i = 0; i < Npt; i++, tv++, fv++) {
    … …  
    9093    Po = (Pc + Ps) / (2*var);
    9194
    92     power[0].elements[Np] = Po;
    93     period[0].elements[Np] = P;
     95    power[0].elements.Flt[Np] = Po;
     96    period[0].elements.Flt[Np] = P;
    9497    Np ++;
    9598    if (Np >= NP) {
    9699      NP += 100;
    97       REALLOCATE (power[0].elements, float, NP);
    98       REALLOCATE (period[0].elements, float, NP);
     100      REALLOCATE (power[0].elements.Flt, opihi_flt, NP);
     101      REALLOCATE (period[0].elements.Flt, opihi_flt, NP);
    99102    }
    100103
    … …  
    106109  }
    107110
    108   power[0].Nelements = Np;
    109   period[0].Nelements = Np;
    110   REALLOCATE (power[0].elements, float, Np);
    111   REALLOCATE (period[0].elements, float, Np);
     111  ResetVector (power,  OPIHI_FLT, Np);
     112  ResetVector (period, OPIHI_FLT, Np);
    112113 
    113114  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/plot.c

    r13479 r20936  
    5858  if (!KapaPrepPlot (kapa, Npts, &graphmode)) return (FALSE);
    5959 
    60   KapaPlotVector (kapa, Npts, xvec[0].elements, "x");
    61   KapaPlotVector (kapa, Npts, yvec[0].elements, "y");
     60  PlotVectorSingle (kapa, xvec, "x");
     61  PlotVectorSingle (kapa, yvec, "y");
    6262  if (graphmode.etype & 0x01) {
    63     KapaPlotVector (kapa, Npts, dymvec[0].elements, "dym");
    64     KapaPlotVector (kapa, Npts, dypvec[0].elements, "dyp");
     63    PlotVectorSingle (kapa, dymvec, "dym");
     64    PlotVectorSingle (kapa, dypvec, "dyp");
    6565  }
    6666  if (graphmode.etype & 0x02) {
    67     KapaPlotVector (kapa, Npts, dxmvec[0].elements, "dxm");
    68     KapaPlotVector (kapa, Npts, dxpvec[0].elements, "dxp");
     67    PlotVectorSingle (kapa, dxmvec, "dxm");
     68    PlotVectorSingle (kapa, dxpvec, "dxp");
    6969  }
    7070  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/read_vectors.c

    r17070 r20936  
    7070      return (FALSE);   
    7171    }
     72    // XXX we could allow flags (eg, N.i) to specify INT vs FLT types vectors...
    7273    colstr = argv[2*i+2];
    7374    for (j = 0; j < strlen (colstr); j++) {
    … …  
    8182    col[i] = atof (colstr);
    8283  }
    83  
     84
     85  // currently, all read vectors are forced to be type FLT
    8486  NELEM = 1000;
    8587  for (i = 0; i < Nvec; i++) {
    86     REALLOCATE (vec[i][0].elements, float, NELEM);
     88    ResetVector (vec[i], OPIHI_FLT, NELEM);
    8789  }
    8890 
    … …  
    121123        for (i = 0; (i < Nvec) && status; i++) {
    122124          status = dparse (&value, col[i], c0);
    123           vec[i][0].elements[N] = value;
    124           if (!status) vec[i][0].elements[N] = 0.0/0.0;
     125          vec[i][0].elements.Flt[N] = value;
     126          if (!status) vec[i][0].elements.Flt[N] = NAN;
    125127        }
    126128        if (status) N++;
    … …  
    130132        NELEM += 1000;
    131133        for (i = 0; i < Nvec; i++) {
    132           REALLOCATE (vec[i][0].elements, float, NELEM);
     134          REALLOCATE (vec[i][0].elements.Flt, opihi_flt, NELEM);
    133135        }
    134136      }
    … …  
    137139  }
    138140  for (i = 0; i < Nvec; i++) {
    139     REALLOCATE (vec[i][0].elements, float, MAX (N,1));
     141    REALLOCATE (vec[i][0].elements.Flt, opihi_flt, MAX (N,1));
    140142    vec[i][0].Nelements = N;
    141143  }
    … …  
    157159int read_table_vectors (int argc, char **argv, char *extname) {
    158160
    159   int i, j, k, N, Nbytes, Nextend, Ny, Binary;
     161  int i, j, k, N, Nbytes, Nextend, Ny, Binary, vecType;
    160162  char type[16], ID[80], *CCDKeyword;
    161163  FTable table;
    … …  
    260262    }
    261263    if (Nval == 0) ESCAPE ("no data for field in table");
    262 
     264   
     265    vecType = OPIHI_INT;
     266    if (!strcmp (type, "double") || !strcmp (type, "float")) {
     267      vecType = OPIHI_FLT;
     268    }
     269       
     270    // define the multifield vector names
    263271    ALLOCATE (vec, Vector *, Nval);
    264272    for (j = 0; j < Nval; j++) {
    … …  
    268276        sprintf (name, "%s:%d", argv[i], j);
    269277      if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) ESCAPE ("bad vector name");
    270       REALLOCATE (vec[j][0].elements, float, MAX (Ny,1));
    271       vec[j][0].Nelements = Ny;
     278      ResetVector (vec[j], vecType, MAX (Ny,1));
    272279    }
    273280
    … …  
    276283      for (j = 0; j < Ny; j++) {
    277284        for (k = 0; k < Nval; k++, Pd++) {
    278           vec[k][0].elements[j] = *Pd;
     285          vec[k][0].elements.Flt[j] = *Pd;
    279286        }
    280287      }
    … …  
    284291      for (j = 0; j < Ny; j++) {
    285292        for (k = 0; k < Nval; k++, Pf++) {
    286           vec[k][0].elements[j] = *Pf;
     293          vec[k][0].elements.Flt[j] = *Pf;
    287294        }
    288295      }
    … …  
    292299      for (j = 0; j < Ny; j++) {
    293300        for (k = 0; k < Nval; k++, Pi++) {
    294           vec[k][0].elements[j] = *Pi;
     301          vec[k][0].elements.Int[j] = *Pi;
    295302        }
    296303      }
    … …  
    300307      for (j = 0; j < Ny; j++) {
    301308        for (k = 0; k < Nval; k++, Ps++) {
    302           vec[k][0].elements[j] = *Ps;
     309          vec[k][0].elements.Int[j] = *Ps;
    303310        }
    304311      }
    … …  
    308315      for (j = 0; j < Ny; j++) {
    309316        for (k = 0; k < Nval; k++, Pc++) {
    310           vec[k][0].elements[j] = *Pc;
     317          vec[k][0].elements.Int[j] = *Pc;
    311318        }
    312319      }

  • trunk/Ohana/src/opihi/cmd.data/select.c

    r7917 r20936  
    2727  /* check size of in1, in2, tvec: must match */
    2828
    29   REALLOCATE (ovec[0].elements, float, MAX (tvec[0].Nelements, 1));
    30   for (i = 0; i < tvec[0].Nelements; i++) {
    31     ovec[0].elements[i] = tvec[0].elements[i] ? in1[0].elements[i] : in2[0].elements[i];
     29  if ((in1->type == OPIHI_INT) && (in2->type == OPIHI_INT)) {
     30    ResetVector (ovec, OPIHI_INT, MAX (tvec[0].Nelements, 1));
     31  } else {
     32    ResetVector (ovec, OPIHI_FLT, MAX (tvec[0].Nelements, 1));
    3233  }
    33   ovec[0].Nelements = tvec[0].Nelements;
    34   REALLOCATE (ovec[0].elements, float, MAX (ovec[0].Nelements, 1));
     34
     35  // (in1 and in2) == (flt or int) and tvec == (flt or int)
     36  if ((in1->type == OPIHI_FLT) && (in2->type == OPIHI_FLT) && (tvec->type == OPIHI_FLT)) {
     37    for (i = 0; i < tvec[0].Nelements; i++) {
     38      ovec[0].elements.Flt[i] = tvec[0].elements.Flt[i] ? in1[0].elements.Flt[i] : in2[0].elements.Flt[i];
     39    }
     40  }
     41  if ((in1->type == OPIHI_FLT) && (in2->type == OPIHI_FLT) && (tvec->type == OPIHI_INT)) {
     42    for (i = 0; i < tvec[0].Nelements; i++) {
     43      ovec[0].elements.Flt[i] = tvec[0].elements.Int[i] ? in1[0].elements.Flt[i] : in2[0].elements.Flt[i];
     44    }
     45  }
     46  if ((in1->type == OPIHI_INT) && (in2->type == OPIHI_FLT) && (tvec->type == OPIHI_FLT)) {
     47    for (i = 0; i < tvec[0].Nelements; i++) {
     48      ovec[0].elements.Flt[i] = tvec[0].elements.Flt[i] ? in1[0].elements.Int[i] : in2[0].elements.Flt[i];
     49    }
     50  }
     51  if ((in1->type == OPIHI_INT) && (in2->type == OPIHI_FLT) && (tvec->type == OPIHI_INT)) {
     52    for (i = 0; i < tvec[0].Nelements; i++) {
     53      ovec[0].elements.Flt[i] = tvec[0].elements.Int[i] ? in1[0].elements.Int[i] : in2[0].elements.Flt[i];
     54    }
     55  }
     56  if ((in1->type == OPIHI_FLT) && (in2->type == OPIHI_INT) && (tvec->type == OPIHI_FLT)) {
     57    for (i = 0; i < tvec[0].Nelements; i++) {
     58      ovec[0].elements.Flt[i] = tvec[0].elements.Flt[i] ? in1[0].elements.Flt[i] : in2[0].elements.Int[i];
     59    }
     60  }
     61  if ((in1->type == OPIHI_FLT) && (in2->type == OPIHI_INT) && (tvec->type == OPIHI_INT)) {
     62    for (i = 0; i < tvec[0].Nelements; i++) {
     63      ovec[0].elements.Flt[i] = tvec[0].elements.Int[i] ? in1[0].elements.Flt[i] : in2[0].elements.Int[i];
     64    }
     65  }
     66  if ((in1->type == OPIHI_INT) && (in2->type == OPIHI_INT) && (tvec->type == OPIHI_FLT)) {
     67    for (i = 0; i < tvec[0].Nelements; i++) {
     68      ovec[0].elements.Int[i] = tvec[0].elements.Flt[i] ? in1[0].elements.Int[i] : in2[0].elements.Int[i];
     69    }
     70  }
     71  if ((in1->type == OPIHI_INT) && (in2->type == OPIHI_INT) && (tvec->type == OPIHI_INT)) {
     72    for (i = 0; i < tvec[0].Nelements; i++) {
     73      ovec[0].elements.Int[i] = tvec[0].elements.Int[i] ? in1[0].elements.Int[i] : in2[0].elements.Int[i];
     74    }
     75  }
    3576 
    3677  DeleteVector (tvec);

  • trunk/Ohana/src/opihi/cmd.data/sort.c

    r7917 r20936  
    11# include "data.h"
    22
     3void fsortindex (opihi_flt *X, int *IDX, int N) {
     4
     5# define SWAPFUNC(A,B){ opihi_flt tmp; int itmp;        \
     6  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
     7  itmp = IDX[A]; IDX[A] = IDX[B]; IDX[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
     16}
     17
     18void isortindex (opihi_int *X, int *IDX, int N) {
     19
     20# define SWAPFUNC(A,B){ opihi_int tmp; int itmp;        \
     21  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
     22  itmp = IDX[A]; IDX[A] = IDX[B]; IDX[B] = itmp; \
     23}
     24# define COMPARE(A,B)(X[A] < X[B])
     25
     26  OHANA_SORT (N, COMPARE, SWAPFUNC);
     27
     28# undef SWAPFUNC
     29# undef COMPARE
     30
     31}
     32
     33// XXX add an option to NOT sort, but return an index instead?
    334int sort_vectors (int argc, char **argv) {
    435 
    536  int i, j, Nvec, Nval;
    6   float *temp, *index, *T, *V, *I;
     37  opihi_flt *ftemp;
     38  opihi_int *itemp;
     39  int *index, *I;
    740  Vector **vec;
    841
    … …  
    3568  }
    3669 
    37   /* create index (use float to use sortpair) */
    38   ALLOCATE (index, float, Nval);
     70  /* create index */
     71  ALLOCATE (index, int, Nval);
    3972  for (i = 0; i < Nval; i++) index[i] = i;
    4073
    4174  /* sort key & index */
    42   fsortpair (vec[0][0].elements, index, Nval);
     75  if (vec[0][0].type == OPIHI_FLT) {
     76    fsortindex (vec[0][0].elements.Flt, index, Nval);
     77  } else {
     78    isortindex (vec[0][0].elements.Int, index, Nval);
     79  }
    4380
    44   ALLOCATE (temp, float, Nval);
     81  ALLOCATE (ftemp, opihi_flt, Nval);
     82  ALLOCATE (itemp, opihi_int, Nval);
     83
    4584  for (i = 1; i < Nvec; i++) {
    46     T = temp;
    47     V = vec[i][0].elements;
    48     I = index;
    49     for (j = 0; j < Nval; j++, T++, I++) {
    50       *T = V[(int)(*I)];
     85    if (vec[i][0].type == OPIHI_FLT) {
     86      opihi_flt *T = ftemp;
     87      opihi_flt *V = vec[i][0].elements.Flt;
     88      I = index;
     89      for (j = 0; j < Nval; j++, T++, I++) {
     90        *T = V[*I];
     91      }
     92      /* swap .elements.Flt (== V) and ftemp */
     93      vec[i][0].elements.Flt = ftemp;
     94      ftemp = V;
     95    } else {
     96      opihi_int *T = itemp;
     97      opihi_int *V = vec[i][0].elements.Int;
     98      I = index;
     99      for (j = 0; j < Nval; j++, T++, I++) {
     100        *T = V[*I];
     101      }
     102      /* swap .elements.Flt (== V) and itemp */
     103      vec[i][0].elements.Int = itemp;
     104      itemp = V;
    51105    }
    52     /* swap .elements (== V) and temp */
    53     vec[i][0].elements = temp;
    54     temp = V;
    55106  }
    56   free (temp);
     107  free (itemp);
     108  free (ftemp);
    57109  free (vec);
    58110  free (index);
    … …  
    61113
    62114}
    63 
    64 

  • trunk/Ohana/src/opihi/cmd.data/subset.c

    r7917 r20936  
    66 
    77  char *out;
    8   int  i, j, size;
     8  int  i, Npts, size;
    99  Vector *ivec, *ovec, *tvec;
    1010
    … …  
    2828  /* check size of ivec, tvec: must match */
    2929
    30   REALLOCATE (ovec[0].elements, float, MAX (tvec[0].Nelements, 1));
    31   for (j = i = 0; i < tvec[0].Nelements; i++) {
    32     if (tvec[0].elements[i]) {
    33       ovec[0].elements[j] = ivec[0].elements[i];
    34       j++;
     30  // ovec matches ivec in type
     31  ResetVector (ovec, ivec->type, MAX (tvec[0].Nelements, 1));
     32
     33  // we have four cases: (ivec == flt or int) and (tvec == flt or int)
     34  if ((ivec->type == OPIHI_FLT) && (tvec->type == OPIHI_FLT)) {
     35    opihi_flt *vi = ivec[0].elements.Flt;
     36    opihi_flt *vt = tvec[0].elements.Flt;
     37    for (Npts = i = 0; i < tvec[0].Nelements; i++, vi++, vt++) {
     38      if (!*vt) continue;
     39      ovec[0].elements.Flt[Npts] = *vi;
     40      Npts++;
    3541    }
    3642  }
    37   ovec[0].Nelements = j;
    38   REALLOCATE (ovec[0].elements, float, MAX (ovec[0].Nelements, 1));
     43  if ((ivec->type == OPIHI_FLT) && (tvec->type == OPIHI_INT)) {
     44    opihi_flt *vi = ivec[0].elements.Flt;
     45    opihi_int *vt = tvec[0].elements.Int;
     46    for (Npts = i = 0; i < tvec[0].Nelements; i++, vi++, vt++) {
     47      if (!*vt) continue;
     48      ovec[0].elements.Flt[Npts] = *vi;
     49      Npts++;
     50    }
     51  }
     52  if ((ivec->type == OPIHI_INT) && (tvec->type == OPIHI_FLT)) {
     53    opihi_int *vi = ivec[0].elements.Int;
     54    opihi_flt *vt = tvec[0].elements.Flt;
     55    for (Npts = i = 0; i < tvec[0].Nelements; i++, vi++, vt++) {
     56      if (!*vt) continue;
     57      ovec[0].elements.Int[Npts] = *vi;
     58      Npts++;
     59    }
     60  }
     61  if ((ivec->type == OPIHI_INT) && (tvec->type == OPIHI_INT)) {
     62    opihi_int *vi = ivec[0].elements.Int;
     63    opihi_int *vt = tvec[0].elements.Int;
     64    for (Npts = i = 0; i < tvec[0].Nelements; i++, vi++, vt++) {
     65      if (!*vt) continue;
     66      ovec[0].elements.Int[Npts] = *vi;
     67      Npts++;
     68    }
     69  }
     70
     71  // free up unused memory
     72  ResetVector (ovec, ivec->type, MAX (Npts, 1));
    3973
    4074  DeleteVector (tvec);

  • trunk/Ohana/src/opihi/cmd.data/svd.c

    r7917 r20936  
    44 
    55  int i, Nx, Ny, status;
    6   float *in, *out, *A, *U, *W, *V;
     6  float *in, *out, *A, *U, *V;
     7  Buffer *Ma, *Mu, *Mv;
    78  Vector *Vw;
    8   Buffer *Ma, *Mu, *Mv;
     9  opihi_flt *W;
    910
    1011  if (argc != 6) goto usage;
    … …  
    4243
    4344  /* w is Nx */
    44   Vw[0].Nelements = Nx;
    45   REALLOCATE (Vw[0].elements, float, Nx);
     45  ResetVector (Vw, OPIHI_FLT, Nx);
    4646
    4747  /* pointers to the various arrays */
    4848  A = (float *) Ma[0].matrix.buffer;
    4949  U = (float *) Mu[0].matrix.buffer;
    50   W = (float *) Vw[0].elements;
    5150  V = (float *) Mv[0].matrix.buffer;
     51  W = Vw[0].elements.Flt;
    5252
    5353  /* copy A to U (svdcmp replaces A with U) */

  • trunk/Ohana/src/opihi/cmd.data/test/applyfit2d.sh

    r16056 r20936  
    3232
    3333# Memory test
     34# NOTE: requires test1 to be run first
    3435macro memtest1
    3536
    … …  
    4849 $PASS = 1
    4950
    50  if ($endmem - $startmem > 10)
     51 if (($endmem - $startmem)/1000 > 1.0)
    5152   $PASS = 0
    5253   echo "growth: {$endmem-$startmem}"

  • trunk/Ohana/src/opihi/cmd.data/test/fit.sh

    r16431 r20936  
    4747 if ($Cn != 1)
    4848   $PASS = 0
    49  end
    50  if (abs($C0 - 3) > 0.01)
    51    $PASS = 0
    52  end
    53  if (abs($C1 - 5) > 0.01)
    54    $PASS = 0
     49   echo "wrong number of elements : $Cn"
     50 end
     51 if (abs($C0 - 3) > 0.06)
     52   $PASS = 0
     53   echo "wrong value for C0 : $C0"
     54 end
     55 if (abs($C1 - 5) > 0.06)
     56   $PASS = 0
     57   echo "wrong value for C1 : $C1"
    5558 end
    5659end
    … …  
    7275   $PASS = 0
    7376 end
    74  if (abs($C0 - 3) > 0.02)
    75    $PASS = 0
    76  end
    77  if (abs($C1 - 5) > 0.02)
     77 if (abs($C0 - 3) > 0.06)
     78   $PASS = 0
     79 end
     80 if (abs($C1 - 5) > 0.06)
    7881   $PASS = 0
    7982 end
    … …  
    102105   $PASS = 0
    103106 end
    104  if (abs($C0 - 3) > 0.02)
    105    $PASS = 0
    106  end
    107  if (abs($C1 - 5) > 0.02)
     107 if (abs($C0 - 3) > 0.06)
     108   $PASS = 0
     109 end
     110 if (abs($C1 - 5) > 0.06)
    108111   $PASS = 0
    109112 end
    … …  
    150153   $PASS = 0
    151154 end
    152  if (abs($C0 - 3) > 0.05)
    153    $PASS = 0
    154  end
    155  if (abs($C1 - 5) > 0.05)
    156    $PASS = 0
    157  end
    158  if (abs($C2 + 4) > 0.05)
     155 if (abs($C0 - 3) > 0.06)
     156   $PASS = 0
     157 end
     158 if (abs($C1 - 5) > 0.06)
     159   $PASS = 0
     160 end
     161 if (abs($C2 + 4) > 0.06)
    159162   $PASS = 0
    160163 end
    … …  
    177180   $PASS = 0
    178181 end
    179  if (abs($C0 - 3) > 0.05)
    180    $PASS = 0
    181  end
    182  if (abs($C1 - 5) > 0.05)
    183    $PASS = 0
    184  end
    185  if (abs($C2 + 4) > 0.05)
     182 if (abs($C0 - 3) > 0.06)
     183   $PASS = 0
     184 end
     185 if (abs($C1 - 5) > 0.06)
     186   $PASS = 0
     187 end
     188 if (abs($C2 + 4) > 0.06)
    186189   $PASS = 0
    187190 end
    … …  
    212215   $PASS = 0
    213216 end
    214  if (abs($C0 - 3) > 0.05)
    215    $PASS = 0
    216  end
    217  if (abs($C1 - 5) > 0.05)
    218    $PASS = 0
    219  end
    220  if (abs($C2 + 4) > 0.05)
    221    $PASS = 0
    222  end
    223 end
     217 if (abs($C0 - 3) > 0.06)
     218   $PASS = 0
     219 end
     220 if (abs($C1 - 5) > 0.06)
     221   $PASS = 0
     222 end
     223 if (abs($C2 + 4) > 0.06)
     224   $PASS = 0
     225 end
     226end

  • trunk/Ohana/src/opihi/cmd.data/test/gaussj.sh

    r16269 r20936  
    232232 for i 0 B[]
    233233  for j 0 B[]
     234   # echo $i $j meas[$i] inA[$i][$j] B[$j] {inA[$i][$j] * B[$j]} {meas[$i] + inA[$i][$j] * B[$j]}
    234235   meas[$i] = meas[$i] + inA[$i][$j] * B[$j]
     236   # echo "-> meas[$i]"
    235237  end
    236238 end
    … …  
    238240 for i 0 inB[]
    239241  if (abs(inB[$i]-meas[$i]) > 1e-5)
     242    echo inB[$i] meas[$i] {abs(inB[$i]-meas[$i])}
    240243    $PASS = 0
    241244  end

  • trunk/Ohana/src/opihi/cmd.data/test/histogram.sh

    r16056 r20936  
    1212 local i
    1313
    14  create x 0 10 0.1
     14 # set data values at the i*0.1 + 0.05 values so round-off does not causs miscounts
     15 create x 0.05 10.05 0.1
    1516
    1617 for i 45 55
    … …  
    1819 end
    1920
     21 # histogram bins are 0-0.1, 0.1-0.2, etc
    2022 histogram x xhis 0 10 0.1
    2123

  • trunk/Ohana/src/opihi/cmd.data/test/peak.sh

    r14176 r20936  
    2121   $PASS = 0
    2222 end
    23  if ($peaknum != 51)
     23 if ($peaknum != 50)
    2424   $PASS = 0
    2525 end
    … …  
    4343   $PASS = 0
    4444 end
    45  if ($peaknum != 51)
     45 if ($peaknum != 50)
    4646   $PASS = 0
    4747 end
    … …  
    6767   $PASS = 0
    6868 end
    69  if ($peaknum != 51)
     69 if ($peaknum != 50)
    7070   $PASS = 0
    7171 end

  • trunk/Ohana/src/opihi/cmd.data/test/vgauss.sh

    r10069 r20936  
    2020
    2121 vgauss -q x y dy yfit
     22 # lim x y; clear; box; plot -x 1 -c black x y; plot -c red x yfit
     23 # cursor
    2224
    2325 if (abs($C0 - 0.0) > 0.01)
    … …  
    5153
    5254 vgauss -q x y dy yfit
     55 # lim x y; clear; box; plot -x 1 -c black x y; plot -c red x yfit
     56 # cursor
    5357
    5458 if (abs($C0 - 0.0) > 0.01)
    … …  
    7175 break -auto off
    7276
     77 $C0o = 0.5
     78 $C1o = 2
     79 $C2o = 900
     80 $C3o = 1
     81
    7382 create x -10 10 0.1
    74  set y = 1000 * exp(-0.5*x^2/3^2)
     83 set y = $C3o + $C2o * exp(-0.5*(x - $C0o)^2/$C1o^2)
    7584
    7685 gaussdev dY y[] 0.0 1.0
    … …  
    7887 set y = y + dy
    7988
    80  $C0 = 0.5
    81  $C1 = 2
    82  $C2 = 900
    83  $C3 = 1
     89 $C0 = $C0o + 2
     90 $C1 = $C1o + 2
     91 $C2 = $C2o + 50
     92 $C3 = $C3o + 10
    8493
    8594 vgauss -q x y dy yfit
     95 # lim x y; clear; box; plot -x 1 -c black x y; plot -c red x yfit
     96 # cursor
    8697
    87  if (abs($C0 - 0.0) > 0.01)
     98 $dS = 3.0 / sqrt(y[])
     99
     100 if (abs($C0 - $C0o) > $dS)
    88101   $PASS = 0
    89102 end
    90  if (abs($C1 - 3.0) > 0.01)
     103 if (abs($C1 - $C1o)/$C1o > $dS)
    91104   $PASS = 0
    92105 end
    93  if (abs($C2 - 1000.0) > 1)
     106 if (abs($C2 - $C2o)/$C2o > $dS)
    94107   $PASS = 0
    95108 end
    96  if (abs($C3 - 0.0) > 0.2)
     109 if (abs($C3 - $C3o) > $dS)
    97110   $PASS = 0
    98111 end

  • trunk/Ohana/src/opihi/cmd.data/test/vmaxwell.sh

    r10069 r20936  
    4040 break -auto off
    4141
     42 $C0o = 250
     43 $C1o = 25
     44 $C2o = 100
     45 $C3o = 1
     46 $C4o = 10
     47
    4248 create x 0 1000 1
    43  set y = 1000 * (x-200)^2 * exp(-0.5*(x-300)^2/30^2)
    44  set dy = (rnd(y) - 0.5)/0.5
     49 set y = $C2o * (x-$C4o)^2 * exp(-0.5*(x-$C0o)^2/$C1o^2) + $C3o
     50 gaussdev dY y[] 0.0 1.0
     51 set dy = dY * sqrt(y)
    4552 set y = y + dy
    4653
    47  lim x y; clear; box; plot -x 1 -c black x y
     54 $C0 = $C0o + 20
     55 $C1 = $C1o + 2
     56 $C2 = $C2o + 100
     57 $C3 = $C3o + 10
     58 $C4 = $C4o + 20
    4859
    49  $C0 = 250
    50  $C1 = 25
    51  $C2 = 900
    52  $C3 = 1
    53  $C4 = 190
     60 vmaxwell -q x y dy yfit
     61 lim x y; clear; box; plot -x 1 -c black x y; plot x yfit -c red
    5462
    55  vmaxwell x y dy yfit
    56  plot x yfit -c red
     63 $dS = 6.0 / sqrt(y[])
    5764
    58  if (abs($C0 - 0.0) > 0.01)
     65 if (abs($C0 - $C0o) > $dS)
    5966   $PASS = 0
    6067 end
    61  if (abs($C1 - 3.0) > 0.01)
     68 if (abs($C1 - $C1o)/$C1o > $dS)
    6269   $PASS = 0
    6370 end
    64  if (abs($C2 - 1000.0) > 0.1)
     71 if (abs($C2 - $C2o)/$C2o > $dS)
    6572   $PASS = 0
    6673 end
    67  if (abs($C3 - 0.0) > 0.1)
     74 if (abs($C3 - $C3o) > $dS)
     75   $PASS = 0
     76 end
     77 if (abs($C4 - $C4o)/$C4o > $dS)
    6878   $PASS = 0
    6979 end

  • trunk/Ohana/src/opihi/cmd.data/ungridify.c

    r7917 r20936  
    11# include "data.h"
    22
     3// XXX adapt this to accept an optional region to limit the areas, otherwise use the whole image
    34int ungridify (int argc, char **argv) {
    45
    … …  
    67  int Nx, Ny, NX, NY;
    78  int Xmin, Xmax, Ymin, Ymax;
    8   float *v, *x, *y, *z;
    99  Buffer *bf;
     10  float *v;
    1011  Vector *vx, *vy, *vz;
     12  opihi_flt *x, *y, *z;
    1113
    1214  if (argc != 9) {
    1315    gprint (GP_ERR, "USAGE: ungridify buffer Xmin Xmax Ymin Ymax x y z\n");
     16    gprint (GP_ERR, "  convert a portion of an image to a collection a triplet of vectors\n");
    1417    return (FALSE);
    1518  }
    … …  
    2932  if ((vy = SelectVector (argv[7], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    3033  if ((vz = SelectVector (argv[8], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    31   REALLOCATE (vx[0].elements, float, Nx*Ny);
    32   REALLOCATE (vy[0].elements, float, Nx*Ny);
    33   REALLOCATE (vz[0].elements, float, Nx*Ny);
    3434
    35   x = vx[0].elements;
    36   y = vy[0].elements;
    37   z = vz[0].elements;
     35  ResetVector (vx, OPIHI_FLT, Nx*Ny);
     36  ResetVector (vy, OPIHI_FLT, Nx*Ny);
     37  ResetVector (vz, OPIHI_FLT, Nx*Ny);
     38
     39  x = vx[0].elements.Flt;
     40  y = vy[0].elements.Flt;
     41  z = vz[0].elements.Flt;
    3842  n = 0;
    3943  v = (float *)bf[0].matrix.buffer;
    4044  for (j = Ymin; j < Ymax; j++) {
    4145    for (i = Xmin; i < Xmax; i++, x++, y++, z++, n++) {
    42       vx[0].elements[n] = i;
    43       vy[0].elements[n] = j;
     46      vx[0].elements.Flt[n] = i;
     47      vy[0].elements.Flt[n] = j;
    4448      if (i < 0) continue;
    4549      if (i >= NX) continue;
    4650      if (j < 0) continue;
    4751      if (j >= NY) continue;
    48       vz[0].elements[n] = v[i+j*NX];
     52      vz[0].elements.Flt[n] = v[i+j*NX];
    4953    }
    5054  }
    5155  if (n != Nx*Ny) {
    5256    gprint (GP_ERR, "error in ungrid: %d vs %d (%d x %d)\n", n, Nx*Ny, Nx, Ny);
     57    gprint (GP_ERR, "(this is probably a programming error in ungridify)\n");
    5358  }
    5459  vx[0].Nelements = vy[0].Nelements = vz[0].Nelements = n;

  • trunk/Ohana/src/opihi/cmd.data/uniq.c

    r7917 r20936  
    44 
    55  int Nnew, i, j, found;
    6   float *v1, *v2;
    76  Vector *ivec, *ovec;
    87
    … …  
    1615
    1716  /* allocate the maximum possible needed */
    18   ALLOCATE (ovec[0].elements, float, ivec[0].Nelements);
     17  ResetVector (ovec, ivec->type, ivec->Nelements);
    1918
    2019  Nnew = 0;
    21   v1 = ivec[0].elements;
    22   for (i = 0; i < ivec[0].Nelements; i++, v1++) {
    23     v2 = ovec[0].elements;
    24     found = FALSE;
    25     for (j = 0; !found && (j < Nnew); j++, v2++) {
    26       if (*v1 == *v2) found = TRUE;
     20
     21  if (ivec->type == OPIHI_FLT) {
     22    opihi_flt *v1 = ivec[0].elements.Flt;
     23    for (i = 0; i < ivec[0].Nelements; i++, v1++) {
     24      opihi_flt *v2 = ovec[0].elements.Flt;
     25      found = FALSE;
     26      for (j = 0; !found && (j < Nnew); j++, v2++) {
     27        if (*v1 == *v2) found = TRUE;
     28      }
     29      if (!found) {
     30        ovec[0].elements.Flt[Nnew] = *v1;
     31        Nnew ++;
     32      }
    2733    }
    28     if (!found) {
    29       ovec[0].elements[Nnew] = *v1;
    30       Nnew ++;
     34  } else {
     35    opihi_int *v1 = ivec[0].elements.Int;
     36    for (i = 0; i < ivec[0].Nelements; i++, v1++) {
     37      opihi_int *v2 = ovec[0].elements.Int;
     38      found = FALSE;
     39      for (j = 0; !found && (j < Nnew); j++, v2++) {
     40        if (*v1 == *v2) found = TRUE;
     41      }
     42      if (!found) {
     43        ovec[0].elements.Int[Nnew] = *v1;
     44        Nnew ++;
     45      }
    3146    }
    3247  }
    3348
    34   ovec[0].Nelements = Nnew;
    35   REALLOCATE (ovec[0].elements, float, ovec[0].Nelements);
     49  // free up extra memory
     50  ResetVector (ovec, ivec->type, Nnew);
    3651
    3752  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/vbin.c

    r7917 r20936  
    55  int i, j, n, N, Nin, Nout;
    66  int Normalize, Ignore;
    7   float *Vout, *Vin, IgnoreValue;
     7  opihi_flt *Vout, IgnoreValue;
    88  double scale;
    99  Vector *in, *out;
    … …  
    4242  Nout = Nin / scale;
    4343
    44   REALLOCATE (out[0].elements, float, Nout);
    45   out[0].Nelements = Nout;
     44  // re-binning creates a float vector
     45  ResetVector (out, OPIHI_FLT, in[0].Nelements);
    4646
    47   Vin  = in[0].elements;
    48   Vout = out[0].elements;
    49   for (n = j = 0; j < Nout; j++, Vout++) {
    50     *Vout = 0;
    51     for (N = i = 0; (i < scale) && (n < Nin); n++, i++, Vin++) {
    52       if (!finite (*Vin)) continue;
    53       if (Ignore && (*Vin == IgnoreValue)) continue;
    54       *Vout += *Vin;
    55       N ++;
    56     }
    57     if (Normalize) {
    58       if (N > 0) {
    59         *Vout /= (float) N;
    60       } else {
    61         *Vout = 0;
     47  Vout = out[0].elements.Flt;
     48
     49  if (in[0].type == OPIHI_FLT) {
     50    opihi_flt *Vin  = in[0].elements.Flt;
     51    for (n = j = 0; j < Nout; j++, Vout++) {
     52      *Vout = 0;
     53      for (N = i = 0; (i < scale) && (n < Nin); n++, i++, Vin++) {
     54        if (!finite (*Vin)) continue;
     55        if (Ignore && (*Vin == IgnoreValue)) continue;
     56        *Vout += *Vin;
     57        N ++;
     58      }
     59      if (Normalize) {
     60        if (N > 0) {
     61          *Vout /= (opihi_flt) N;
     62        } else {
     63          *Vout = 0;
     64        }
     65      }
     66    }
     67  } else {
     68    opihi_int *Vin  = in[0].elements.Int;
     69    for (n = j = 0; j < Nout; j++, Vout++) {
     70      *Vout = 0;
     71      for (N = i = 0; (i < scale) && (n < Nin); n++, i++, Vin++) {
     72        if (!finite (*Vin)) continue;
     73        if (Ignore && (*Vin == IgnoreValue)) continue;
     74        *Vout += *Vin;
     75        N ++;
     76      }
     77      if (Normalize) {
     78        if (N > 0) {
     79          *Vout /= (opihi_flt) N;
     80        } else {
     81          *Vout = 0;
     82        }
    6283      }
    6384    }

  • trunk/Ohana/src/opihi/cmd.data/vclip.c

    r7917 r20936  
    33int vclip (int argc, char **argv) {
    44
    5   int i, Npix, DO_NAN, DO_INF, N;
     5  int i, Npix, DO_NAN, DO_INF, DO_CLIP, N;
    66  double min, Vmin, max, Vmax, nan_val, inf_val;
    7   float *in;
    87  Vector *vec;
    98
    … …  
    3332  if ((vec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    3433
     34  DO_CLIP = FALSE;
    3535  if (argc == 6) {
    3636    min = atof (argv[2]);
    … …  
    3838    max = atof (argv[4]);
    3939    Vmax = atof (argv[5]);
     40    DO_CLIP = TRUE;
    4041  }
    4142
     43  if (DO_NAN && vec[0].type == OPIHI_INT) {
     44    gprint (GP_ERR, "  warning : clipping on NAN is invalid for INT vectors\n");
     45    return (FALSE);
     46  }
     47   
     48  if (DO_INF && vec[0].type == OPIHI_INT) {
     49    gprint (GP_ERR, "  warning : clipping on INF is invalid for INT vectors\n");
     50    return (FALSE);
     51  }
     52   
    4253  Npix = vec[0].Nelements;
    43   in =   vec[0].elements;
    4454
    45   if (argc == 6) {
     55  if (vec[0].type == OPIHI_FLT) {
     56    opihi_flt *in =  vec[0].elements.Flt;
    4657    for (i = 0; i < Npix; i++, in++) {
    47       if (*in < min)
     58      if (DO_CLIP && (*in < min)) {
    4859        *in = Vmin;
    49       if (*in > max)
     60      }
     61      if (DO_CLIP && (*in > max)) {
    5062        *in = Vmax;
    51     }
    52   }
    53   in = vec[0].elements;
    54   if (DO_NAN) {
    55     for (i = 0; i < Npix; i++, in++) {
    56       if (isnan (*in)) {
     63      }
     64      if (!finite (*in) && DO_INF) {
     65        *in = inf_val;
     66      }
     67      if (isnan (*in) && DO_NAN) {
    5768        *in = nan_val;
    5869      }
    5970    }
    60   }
    61   in = vec[0].elements;
    62   if (DO_INF) {
     71  } else {
     72    opihi_int *in =  vec[0].elements.Int;
    6373    for (i = 0; i < Npix; i++, in++) {
    64       if (!finite (*in)) {
    65         *in = inf_val;
     74      if (DO_CLIP && (*in < min)) {
     75        *in = Vmin;
     76      }
     77      if (DO_CLIP && (*in > max)) {
     78        *in = Vmax;
    6679      }
    6780    }
    6881  }
    6982  return (TRUE);
    70 
    7183}
    72 
    73 

  • trunk/Ohana/src/opihi/cmd.data/vgauss.c

    r16446 r20936  
    22
    33/* local private functions */
    4 float fgaussOD (float, float *, int, float *);
     4opihi_flt fgaussOD (opihi_flt, opihi_flt *, int, opihi_flt *);
    55
    66# define GET_VAR(V,A) \
    … …  
    1616
    1717  int i, N, Npts, Npar, Quiet;
    18   float par[4], *v1, *v2, *dy, **covar;
    19   float chisq, ochisq, dchisq;
     18  opihi_flt par[4], *v1, *v2, *dy, **covar;
     19  opihi_flt chisq, ochisq, dchisq;
    2020  Vector *xvec, *yvec, *svec, *ovec;
    2121  char *c, name[16];
    … …  
    4242  if ((ovec = SelectVector (argv[4], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    4343
     44  REQUIRE_VECTOR_FLT (xvec, FALSE);
     45  REQUIRE_VECTOR_FLT (yvec, FALSE);
     46  REQUIRE_VECTOR_FLT (svec, FALSE);
     47
    4448  Npts = xvec[0].Nelements;
    45   ALLOCATE (dy, float, Npts);
    46   REALLOCATE (ovec[0].elements, float, Npts);
     49  ResetVector (ovec, OPIHI_FLT, Npts);
     50
     51  ALLOCATE (dy, opihi_flt, Npts);
    4752
    4853  GET_VAR (par[0], "C0");
    … …  
    5257  Npar = 4;
    5358
    54   v1 = svec[0].elements;
     59  // mrqmin takes the inverse variance (do not generate NANs)
     60  v1 = svec[0].elements.Flt;
    5561  v2 = dy;
    5662  for (i = 0; i < Npts; i++, v1++, v2++) {
    … …  
    5864  }
    5965 
    60   ochisq = mrqinit (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fgaussOD, !Quiet);
     66  ochisq = mrqinit (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fgaussOD, !Quiet);
    6167  dchisq = ochisq + 2*Npts;
    6268
    6369  for (i = 0; (i < 20) && ((dchisq > 0.1*(Npts - Npar)) || (dchisq <= 0.0)); i++) {
    64     chisq = mrqmin (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fgaussOD, !Quiet);
     70    chisq = mrqmin (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fgaussOD, !Quiet);
    6571    dchisq = ochisq - chisq;
    6672    ochisq = chisq;
    … …  
    7076
    7177  for (i = 0; i < Npts; i++) {
    72     ovec[0].elements[i] = fgaussOD (xvec[0].elements[i], par, Npar, dy);
     78    ovec[0].elements.Flt[i] = fgaussOD (xvec[0].elements.Flt[i], par, Npar, dy);
    7379  }
    7480  ovec[0].Nelements = Npts;
    … …  
    9096
    9197/* pars: x_o, sigma, I, back */
    92 float fgaussOD (float x, float *par, int Npar, float *dpar) {
     98opihi_flt fgaussOD (opihi_flt x, opihi_flt *par, int Npar, opihi_flt *dpar) {
    9399
    94   float z, r, f;
     100  opihi_flt z, r, f;
    95101
    96102  z = (x - par[0])/par[1];

  • trunk/Ohana/src/opihi/cmd.data/vgrid.c

    r9275 r20936  
    55  int i, Nx, Ny, Xb, Yb;
    66  float Xmin, Xmax, dX, Ymin, Ymax, dY;
    7   float *buf, *val, *x, *y, *z;
     7  float *buf;
     8  opihi_flt *val, *x, *y, *z;
    89  int *Nval;
    910  Buffer *bf;
    … …  
    1213  if (argc != 11) {
    1314    gprint (GP_ERR, "USAGE: vgrid x y z buffer Xmin Xmax dX Ymin Ymax dY\n");
     15    gprint (GP_ERR, "  re-grid values from a triplet of vectors (x,y,z) into an image\n");
     16    gprint (GP_ERR, "  the vectors must be floating-point type\n");
    1417    return (FALSE);
    1518  }
    … …  
    2225  if (vx[0].Nelements != vy[0].Nelements) return (FALSE);
    2326  if (vx[0].Nelements != vz[0].Nelements) return (FALSE);
     27
     28  REQUIRE_VECTOR_FLT (vx, FALSE);
     29  REQUIRE_VECTOR_FLT (vy, FALSE);
     30  REQUIRE_VECTOR_FLT (vz, FALSE);
    2431
    2532  Xmin = atof (argv[5]);
    … …  
    3946  strcpy (bf[0].file, "(empty)");
    4047
    41   ALLOCATE (val, float, Nx*Ny);
    42   bzero (val, Nx*Ny*sizeof(float));
     48  ALLOCATE (val, opihi_flt, Nx*Ny);
     49  bzero (val, Nx*Ny*sizeof(opihi_flt));
    4350  ALLOCATE (Nval, int, Nx*Ny);
    4451  bzero (Nval, Nx*Ny*sizeof(int));
    4552
    46   x = vx[0].elements;
    47   y = vy[0].elements;
    48   z = vz[0].elements;
     53  x = vx[0].elements.Flt;
     54  y = vy[0].elements.Flt;
     55  z = vz[0].elements.Flt;
    4956  for (i = 0; i < vx[0].Nelements; i++, x++, y++, z++) {
    5057    Xb = (*x - Xmin) / dX;

  • trunk/Ohana/src/opihi/cmd.data/vload.c

    r19840 r20936  
    66  int kapa, type;
    77  char *name;
    8   double dx, dy, size, angle;
     8  double dx, dy, angle;
    99  KiiOverlay *overlay;
    1010  Vector *vecx, *vecy;
    … …  
    8282    overlay[i].type = type;
    8383    overlay[i].text = NULL;
    84     overlay[i].x = vecx[0].elements[i]+0.5;
    85     overlay[i].y = vecy[0].elements[i]+0.5;
     84    overlay[i].x = (vecx[0].type == OPIHI_FLT) ? vecx[0].elements.Flt[i] : vecx[0].elements.Int[i];
     85    overlay[i].y = (vecy[0].type == OPIHI_FLT) ? vecy[0].elements.Flt[i] : vecy[0].elements.Int[i];
     86    overlay[i].x += 0.5;
     87    overlay[i].y += 0.5;
    8688    overlay[i].dx = dx;
    8789    overlay[i].dy = dy;

  • trunk/Ohana/src/opihi/cmd.data/vmaxwell.c

    r16446 r20936  
    22
    33/* local private functions */
    4 float fmaxwellOD (float, float *, int, float *);
     4opihi_flt fmaxwellOD (opihi_flt, opihi_flt *, int, opihi_flt *);
    55
    66# define GET_VAR(V,A) \
    … …  
    1616
    1717  int i, N, Npts, Npar, Quiet;
    18   float par[5], *v1, *v2, *dy, **covar;
    19   float chisq, ochisq, dchisq;
     18  opihi_flt par[5], *v1, *v2, *dy, **covar;
     19  opihi_flt chisq, ochisq, dchisq;
    2020  Vector *xvec, *yvec, *svec, *ovec;
    2121  char *c, name[16];
    … …  
    4242  if ((ovec = SelectVector (argv[4], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    4343
     44  REQUIRE_VECTOR_FLT (xvec, FALSE);
     45  REQUIRE_VECTOR_FLT (yvec, FALSE);
     46  REQUIRE_VECTOR_FLT (svec, FALSE);
     47
    4448  Npts = xvec[0].Nelements;
    45   ALLOCATE (dy, float, Npts);
    46   REALLOCATE (ovec[0].elements, float, Npts);
     49  ALLOCATE (dy, opihi_flt, Npts);
     50  ResetVector (ovec, OPIHI_FLT, Npts);
    4751
    4852  GET_VAR (par[0], "C0");
    … …  
    5458  /* careful of variable renomalization */
    5559
    56   v1 = svec[0].elements;
     60  v1 = svec[0].elements.Flt;
    5761  v2 = dy;
    5862  for (i = 0; i < Npts; i++, v1++, v2++) *v2 = 1.0 / (*v1 * *v1);
    5963 
    60   ochisq = mrqinit (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
     64  ochisq = mrqinit (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
    6165  dchisq = ochisq + 2*Npts;
    6266
    63   for (i = 0; (i < 20) && ((dchisq > 0.1*(Npts - Npar)) || (dchisq <= 0.0)); i++) {
    64     chisq = mrqmin (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
     67  for (i = 0; (i < 30) && ((dchisq > 0.1*(Npts - Npar)) || (dchisq <= 0.0)); i++) {
     68    chisq = mrqmin (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
    6569    dchisq = ochisq - chisq;
    6670    ochisq = chisq;
    … …  
    7074
    7175  for (i = 0; i < Npts; i++) {
    72     ovec[0].elements[i] = fmaxwellOD (xvec[0].elements[i], par, Npar, dy);
     76    ovec[0].elements.Flt[i] = fmaxwellOD (xvec[0].elements.Flt[i], par, Npar, dy);
    7377  }
    7478  ovec[0].Nelements = Npts;
    … …  
    9094
    9195/* pars: x_o, -0.5/sigma^2, I, back, ref */
    92 float fmaxwellOD (float x, float *par, int Npar, float *dpar) {
     96// f = C3 + C2*(x - C4)^2 * exp(-0.5*(x - C0)^2 / C1^2)
     97opihi_flt fmaxwellOD (opihi_flt x, opihi_flt *par, int Npar, opihi_flt *dpar) {
    9398
    94   float z, r, f;
     99  opihi_flt z, r, f;
    95100
    96101  z = (x - par[0])/par[1];

  • trunk/Ohana/src/opihi/cmd.data/vpop.c

    r7917 r20936  
    1717
    1818  if (Npix > 1) {
    19     memmove (&vec[0].elements[0], &vec[0].elements[1], Npix*sizeof(float));
     19    if (vec[0].type == OPIHI_FLT) {
     20      memmove (&vec[0].elements.Flt[0], &vec[0].elements.Flt[1], Npix*sizeof(opihi_flt));
     21    } else {
     22      memmove (&vec[0].elements.Int[0], &vec[0].elements.Int[1], Npix*sizeof(opihi_int));
     23    }
    2024  }
    2125  vec[0].Nelements = Npix - 1;

  • trunk/Ohana/src/opihi/cmd.data/vroll.c

    r7917 r20936  
    44
    55  int Npix;
    6   float first;
     6  opihi_flt first;
    77  Vector *vec;
    88
    … …  
    1717  if (Npix < 2) return (TRUE);
    1818
    19   first = vec[0].elements[0];
    20   memmove (&vec[0].elements[0], &vec[0].elements[1], Npix*sizeof(float));
    21   vec[0].elements[Npix-1] = first;
     19  if (vec[0].type == OPIHI_FLT) {
     20    first = vec[0].elements.Flt[0];
     21    memmove (&vec[0].elements.Flt[0], &vec[0].elements.Flt[1], Npix*sizeof(opihi_flt));
     22    vec[0].elements.Flt[Npix-1] = first;
     23  } else {
     24    first = vec[0].elements.Int[0];
     25    memmove (&vec[0].elements.Int[0], &vec[0].elements.Int[1], Npix*sizeof(opihi_int));
     26    vec[0].elements.Int[Npix-1] = first;
     27  }
    2228  return (TRUE);
    2329}

  • trunk/Ohana/src/opihi/cmd.data/vsmooth.c

    r7917 r20936  
    33int vsmooth (int argc, char **argv) {
    44 
    5   int i, n, N, Nx, Ns, Ngauss;
    6   float *vi, *vo, *gauss, *gaussnorm;
    7   float g, s, sigma, Nsigma;
     5  int i, n, N, Nx, Ns, Ngauss, isFloat;
     6  opihi_flt *vf, *vo, *gauss, *gaussnorm;
     7  opihi_int *vi;
     8  float g, s, sigma, Nsigma, value;
    89  Vector *in;
    910
    … …  
    2324  sigma = atof (argv[2]);
    2425  Nx = in[0].Nelements;
    25   vi = in[0].elements;
    2626
    2727  /* build a 1D gaussian */
    2828  Ns = (int) (Nsigma*sigma + 0.5);
    2929  Ngauss = 2*Ns + 1;
    30   ALLOCATE (gaussnorm, float, Ngauss);
     30  ALLOCATE (gaussnorm, opihi_flt, Ngauss);
    3131  gauss = &gaussnorm[Ns];
    3232  for (i = -Ns; i < Ns + 1; i++) {
    … …  
    3434  }
    3535
    36   ALLOCATE (vo, float, Nx);
     36  ALLOCATE (vo, opihi_flt, Nx);
     37
     38  isFloat = (in[0].type == OPIHI_FLT);
     39  vf = in[0].elements.Flt;
     40  vi = in[0].elements.Int;
    3741
    3842  for (i = 0; i < Nx; i++) {
    … …  
    4145      if (i+n < 0) continue;
    4246      if (i+n >= Nx) continue;
    43       s += gauss[n]*vi[i+n];
     47      value = isFloat ? vf[i+n] : vi[i+n];
     48      s += gauss[n]*value;
    4449      g += gauss[n];
    4550    }
    … …  
    4752  }
    4853
    49   free (in[0].elements);
    5054  free (gaussnorm);
    5155
    52   in[0].elements = vo;
     56  if (isFloat) {
     57    free (in[0].elements.Flt);
     58  } else {
     59    free (in[0].elements.Int);
     60  }
     61
     62  // smoothing an int vector results in a float vector
     63  in[0].type = OPIHI_FLT;
     64  in[0].elements.Flt = vo;
    5365  return (TRUE);
    5466}

  • trunk/Ohana/src/opihi/cmd.data/vstat.c

    r7917 r20936  
    55  int i, N;
    66  double max, min, sum, var, dvar, mean, stdev;
    7   float *X, IgnoreValue;
     7  float IgnoreValue;
    88  int Ignore, Quiet;
    99
    … …  
    4141
    4242  /* calculate max, min, mean, sum, npix */
    43   X = vec[0].elements;
    4443  max = -HUGE_VAL;
    4544  min = HUGE_VAL;
    4645  sum = N = 0;
    47   for (i = 0; i < vec[0].Nelements; i++, X++) {
    48     if (!finite (*X)) continue;
    49     if (Ignore && (*X == IgnoreValue)) continue;
    50     max = MAX (*X, max);
    51     min = MIN (*X, min);
    52     sum += *X;
    53     N++;
    54   }     
     46  if (vec[0].type == OPIHI_FLT) {
     47    opihi_flt *X = vec[0].elements.Flt;
     48    for (i = 0; i < vec[0].Nelements; i++, X++) {
     49      if (!finite (*X)) continue;
     50      if (Ignore && (*X == IgnoreValue)) continue;
     51      max = MAX (*X, max);
     52      min = MIN (*X, min);
     53      sum += *X;
     54      N++;
     55    }     
     56  } else {
     57    opihi_int *X = vec[0].elements.Int;
     58    for (i = 0; i < vec[0].Nelements; i++, X++) {
     59      if (!finite (*X)) continue;
     60      if (Ignore && (*X == IgnoreValue)) continue;
     61      max = MAX (*X, max);
     62      min = MIN (*X, min);
     63      sum += *X;
     64      N++;
     65    }     
     66  }
    5567  mean = sum / N;
    5668
    … …  
    6577  ALLOCATE (Nval, int, 1002);
    6678  bzero (Nval, 1000*sizeof(int));
    67   X = vec[0].elements;
    6879  var = 0;
    69   for (i = 0; i < vec[0].Nelements; i++, X++) {
    70     if (!finite (*X)) continue;
    71     if (Ignore && (*X == IgnoreValue)) continue;
    72     bin = MAX (0, MIN (1000, (*X - min) / dx));
    73     Nval[bin] ++;
    74     dvar = (*X - mean);
    75     var += dvar*dvar;
    76   }     
     80  if (vec[0].type == OPIHI_FLT) {
     81    opihi_flt *X = vec[0].elements.Flt;
     82    for (i = 0; i < vec[0].Nelements; i++, X++) {
     83      if (!finite (*X)) continue;
     84      if (Ignore && (*X == IgnoreValue)) continue;
     85      bin = MAX (0, MIN (1000, (*X - min) / dx));
     86      Nval[bin] ++;
     87      dvar = (*X - mean);
     88      var += dvar*dvar;
     89    }     
     90  } else {
     91    opihi_int *X = vec[0].elements.Int;
     92    for (i = 0; i < vec[0].Nelements; i++, X++) {
     93      if (!finite (*X)) continue;
     94      if (Ignore && (*X == IgnoreValue)) continue;
     95      bin = MAX (0, MIN (1000, (*X - min) / dx));
     96      Nval[bin] ++;
     97      dvar = (*X - mean);
     98      var += dvar*dvar;
     99    }     
     100  }
    77101  stdev = sqrt (var / N);
    78102

  • trunk/Ohana/src/opihi/cmd.data/vzload.c

    r17419 r20936  
    5858
    5959  for (i = N = 0; i < Noverlay; i++) {
    60     size = MIN (MAX_OUTPUT_SIZE, (vecz[0].elements[i] - min) / range);
     60    float z = (vecz[0].type == OPIHI_FLT) ? vecz[0].elements.Flt[i] : vecz[0].elements.Int[i];
     61    size = MIN (MAX_OUTPUT_SIZE, (z - min) / range);
    6162    if (size < 0.1) continue;
    6263
    6364    overlay[N].type = type;
    6465    overlay[N].text = NULL;
    65     overlay[N].x = vecx[0].elements[i]+0.5;
    66     overlay[N].y = vecy[0].elements[i]+0.5;
     66    overlay[N].x = (vecx[0].type == OPIHI_FLT) ? vecx[0].elements.Flt[i] : vecx[0].elements.Int[i];
     67    overlay[N].y = (vecy[0].type == OPIHI_FLT) ? vecy[0].elements.Flt[i] : vecy[0].elements.Int[i];
     68
     69    overlay[N].x += 0.5;
     70    overlay[N].y += 0.5;
     71
    6772    overlay[N].angle = 0.0;
    6873

  • trunk/Ohana/src/opihi/cmd.data/write_vectors.c

    r20534 r20936  
    7878    for (i = 0; i < vec[0][0].Nelements; i++) {
    7979      for (j = 0; j < Nvec; j++) {
    80         fprintf (f, "%.10g ", vec[j][0].elements[i]);
     80        if (vec[j][0].type == OPIHI_FLT) {
     81          fprintf (f, "%.12g ", vec[j][0].elements.Flt[i]);
     82        } else {
     83          fprintf (f, "%d ", vec[j][0].elements.Int[i]);
     84        }
    8185      }
    8286      fprintf (f, "\n");
    … …  
    135139    for (j = 0; j < Nvec; j++) {
    136140      if (fmttype[j] == 'd') {
    137         fprintf (f, fmtlist[j], (int)(vec[j][0].elements[i]));
     141        if (vec[j][0].type == OPIHI_FLT) {
     142          fprintf (f, fmtlist[j], (int)(vec[j][0].elements.Flt[i]));
     143        } else {
     144          fprintf (f, fmtlist[j], (int)(vec[j][0].elements.Int[i]));
     145        }
    138146      }
    139147      if (fmttype[j] == 'f') {
    140         fprintf (f, fmtlist[j], (float)(vec[j][0].elements[i]));
     148        if (vec[j][0].type == OPIHI_FLT) {
     149          fprintf (f, fmtlist[j], (float)(vec[j][0].elements.Flt[i]));
     150        } else {
     151          fprintf (f, fmtlist[j], (float)(vec[j][0].elements.Int[i]));
     152        }
    141153      }
    142154    }

  • trunk/Ohana/src/opihi/cmd.data/zplot.c

    r14590 r20936  
    33int zplot (int argc, char **argv) {
    44 
    5   int i, kapa, Npts;
    6   float *in, *out;
     5  int i, kapa;
     6  opihi_flt *out;
    77  double min, range;
    88  Graphdata graphmode;
    … …  
    3131    return (FALSE);
    3232  }
    33   Zvec.Nelements = zvec[0].Nelements;
    34   ALLOCATE (Zvec.elements, float, Zvec.Nelements);
     33  SetVector (&Zvec, OPIHI_FLT, zvec[0].Nelements);
     34  out = Zvec.elements.Flt;
    3535 
    36   in = zvec[0].elements;
    37   out = Zvec.elements;
    38   for (i = 0; i < Zvec.Nelements; i++, in++, out++) {
    39     *out = MIN (1.0, MAX (0.01, (*in - min) / range));
     36  if (zvec[0].type == OPIHI_FLT) {
     37    opihi_flt *in = zvec[0].elements.Flt;
     38    for (i = 0; i < Zvec.Nelements; i++, in++, out++) {
     39      *out = MIN (1.0, MAX (0.01, (*in - min) / range));
     40    }
     41  } else {
     42    opihi_int *in = zvec[0].elements.Int;
     43    for (i = 0; i < Zvec.Nelements; i++, in++, out++) {
     44      *out = MIN (1.0, MAX (0.01, (*in - min) / range));
     45    }
    4046  }
    4147
    … …  
    4450  graphmode.size = -1; /* point size determined by Zvec */
    4551  graphmode.etype = 0; /* no errorbars */
    46   Npts = xvec[0].Nelements;
    47   PlotVectorTriplet (kapa, Npts, xvec[0].elements, yvec[0].elements, Zvec.elements, &graphmode);
     52  PlotVectorTriplet (kapa, xvec, yvec, &Zvec, &graphmode);
    4853
    49   free (Zvec.elements);
     54  free (Zvec.elements.Ptr);
    5055
    5156  return (TRUE);
Note: See TracChangeset for help on using the changeset viewer.