IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 20936


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

big update from eam_branch_20081124 with updates to Opihi math

Location:
trunk/Ohana/src
Files:
8 added
4 deleted
176 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/addstar/Makefile

    r17439 r20936  
    2525load2mass   : $(BIN)/load2mass.$(ARCH)
    2626gztest      : $(BIN)/gztest.$(ARCH)
     27mkcmf       : $(BIN)/mkcmf.$(ARCH)
    2728
    2829all: addstar addstarc addstard addstart sedstar load2mass skycells
    … …  
    222223$(SRC)/SetSignals.$(ARCH).o
    223224
     225MKCMF = \
     226$(SRC)/mkcmf.$(ARCH).o
     227
    224228SKYCELLS = \
    225229$(SRC)/skycells.$(ARCH).o \
    … …  
    230234$(SRC)/sky_tessalation.$(ARCH).o
    231235
    232 $(ADDSTARC) : $(INC)/addstar.h
    233 $(ADDSTARD) : $(INC)/addstar.h
    234 $(ADDSTART) : $(INC)/addstar.h
    235 $(ADDSTAR)  : $(INC)/addstar.h
    236 $(SKYCELLS) : $(INC)/addstar.h
     236$(ADDSTARC)   : $(INC)/addstar.h
     237$(ADDSTARD)   : $(INC)/addstar.h
     238$(ADDSTART)   : $(INC)/addstar.h
     239$(ADDSTAR)    : $(INC)/addstar.h
     240$(SKYCELLS)   : $(INC)/addstar.h
    237241$(LOAD-2MASS) : $(INC)/addstar.h $(INC)/2mass.h
    238 
    239 $(BIN)/addstar.$(ARCH) : $(ADDSTAR)
    240 $(BIN)/addstard.$(ARCH) : $(ADDSTARD)
    241 $(BIN)/addstart.$(ARCH) : $(ADDSTART)
    242 $(BIN)/addstarc.$(ARCH) : $(ADDSTARC)
     242$(MKCMF)      : $(INC)/mkcmf.h
     243
     244$(BIN)/addstar.$(ARCH)     : $(ADDSTAR)
     245$(BIN)/addstard.$(ARCH)    : $(ADDSTARD)
     246$(BIN)/addstart.$(ARCH)    : $(ADDSTART)
     247$(BIN)/addstarc.$(ARCH)    : $(ADDSTARC)
    243248$(BIN)/mkacc-2mass.$(ARCH) : $(MKACC-2MASS)
    244 $(BIN)/sedstar.$(ARCH)   : $(SEDSTAR)
    245 $(BIN)/load2mass.$(ARCH) : $(LOAD-2MASS)
    246 $(BIN)/skycells.$(ARCH) : $(SKYCELLS)
    247 
    248 INSTALL = addstar addstarc addstard addstart sedstar load2mass skycells
     249$(BIN)/sedstar.$(ARCH)     : $(SEDSTAR)
     250$(BIN)/load2mass.$(ARCH)   : $(LOAD-2MASS)
     251$(BIN)/skycells.$(ARCH)    : $(SKYCELLS)
     252$(BIN)/mkcmf.$(ARCH)       : $(MKCMF)
     253
     254INSTALL = addstar addstarc addstard addstart sedstar load2mass skycells mkcmf
    249255
    250256# dependancy rules for binary code #########################

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

    r18427 r20936  
    8787char   STKeyword[64];
    8888char   ExtnameKeyword[64];
     89char   ImageIDKeyword[64];
     90char   SourceIDKeyword[64];
    8991
    9092/* these globals modify the behavior of gstars (KEEP) */

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

    r18427 r20936  
    6767  ScanConfig (config, "OBSERVATORY-LONGITUDE",  "%lf", 0, &Longitude);
    6868  ScanConfig (config, "SUBPIX_DATAFILE",        "%s",  0, SubpixDatafile);
     69
     70  ScanConfig (config, "IMAGE-ID-KEYWORD",       "%s",  0, ImageIDKeyword);
     71  ScanConfig (config, "SOURCE-ID-KEYWORD",      "%s",  0, SourceIDKeyword);
    6972
    7073  if (!ScanConfig (config, "EXTNAME-KEYWORD",        "%s",  0, ExtnameKeyword)) {

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

    r20184 r20936  
    55int ReadImageHeader (Header *header, Image *image, int photcode) {
    66
    7   int Nastro, ccdnum, hour, min, Nx, Ny, haveNx, haveNy;
     7  int Nastro, ccdnum, hour, min, Nx, Ny, haveNx, haveNy, sourceID;
    88  double tmp, sec, Cerror, ZeroPt, FWHM_X, FWHM_Y;
    99  char *c, photname[64], line[80];
    … …  
    178178  }
    179179
     180  if (!gfits_scan (header, ImageIDKeyword, "%d", 1, &image[0].externID)) {
     181    image[0].externID = 0;
     182  }
     183  if (!gfits_scan (header, SourceIDKeyword, "%d", 1, &sourceID)) {
     184    image[0].sourceID = 0;
     185  } else {
     186    if (sourceID > 0xffff) {
     187      fprintf (stderr, "image source ID is surprisingly large: %d, skipping\n", sourceID);
     188      return (FALSE);
     189    }
     190    image[0].sourceID = sourceID;
     191  }
     192
    180193  gfits_scan (header, "ZERO_PT", "%lf", 1, &ZeroPt);
    181194  if (ZeroPt != GetZeroPoint()) {

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

    r17195 r20936  
    193193
    194194      catalog[0].measure[Nmeas].detID     = stars[N].detID;
    195       catalog[0].measure[Nmeas].imageID   = options.imageID;
     195      catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    196196
    197197      catalog[0].measure[Nmeas].dXccd     = stars[N].dX;

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

    r17194 r20936  
    215215
    216216    catalog[0].measure[Nmeas].detID     = stars[N].detID;
    217     catalog[0].measure[Nmeas].imageID   = options.imageID;
     217    catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    218218
    219219    catalog[0].measure[Nmeas].dXccd     = stars[N].dX;
    … …  
    327327
    328328    catalog[0].measure[Nmeas].detID     = stars[N].detID;
    329     catalog[0].measure[Nmeas].imageID   = options.imageID;
     329    catalog[0].measure[Nmeas].imageID   = stars[N].imageID;
    330330
    331331    catalog[0].measure[Nmeas].dXccd     = stars[N].dX;

  • trunk/Ohana/src/delstar/src/parse_time.c

    r12332 r20936  
    3131  gfits_scan (header, UTKeyword, "%s", 1, line);
    3232  /* remove ':' characters */
    33   for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; }
     33  for (c = strchr (line, 0x3a); c != NULL; c = strchr (line, 0x3a)) { *c = ' '; }
    3434  sscanf (line, "%d %d %d", &hour, &min, &sec);
    3535
    3636  /* parse mode line */
    3737  uppercase (DateMode);
    38   for (Ny = 0, c = strchr (DateMode, 'Y'); c != (char ) NULL; c = strchr (c + 1, 'Y'), Ny++);
     38  for (Ny = 0, c = strchr (DateMode, 'Y'); c != NULL; c = strchr (c + 1, 'Y'), Ny++);
    3939  if ((Ny != 2) && (Ny != 4)) {
    4040    Shutdown ("error in DATE-MODE format: %s", DateMode);
    … …  
    4343  pm = strchr (DateMode, 'M');
    4444  pd = strchr (DateMode, 'D');
    45   if ((py == (char *) NULL) || (pm == (char *) NULL) || (pd == (char *) NULL)) {
     45  if ((py == NULL) || (pm == NULL) || (pd == NULL)) {
    4646    Shutdown ("error in DATE-MODE format: %s", DateMode);
    4747  }
    … …  
    6565  gfits_scan (header, DateKeyword, "%s",  1, line);
    6666  /* remove possible separators: ':', '/' '.', '-' */
    67   for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; }
    68   for (c = strchr (line, 0x2f); c != (char *) NULL; c = strchr (line, 0x2f)) { *c = ' '; }
    69   for (c = strchr (line, 0x2e); c != (char *) NULL; c = strchr (line, 0x2e)) { *c = ' '; }
    70   for (c = strchr (line, 0x2d); c != (char *) NULL; c = strchr (line, 0x2d)) { *c = ' '; }
     67  for (c = strchr (line, 0x3a); c != NULL; c = strchr (line, 0x3a)) { *c = ' '; }
     68  for (c = strchr (line, 0x2f); c != NULL; c = strchr (line, 0x2f)) { *c = ' '; }
     69  for (c = strchr (line, 0x2e); c != NULL; c = strchr (line, 0x2e)) { *c = ' '; }
     70  for (c = strchr (line, 0x2d); c != NULL; c = strchr (line, 0x2d)) { *c = ' '; }
    7171
    7272  Nf = 0;

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

    r14590 r20936  
    3131  warn_scan (header, UTKeyword, "%s", 1, line);
    3232  /* remove ':' characters */
    33   for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; }
     33  for (c = strchr (line, 0x3a); c != NULL; c = strchr (line, 0x3a)) { *c = ' '; }
    3434  sscanf (line, "%d %d %d", &hour, &min, &sec);
    3535
    3636  /* parse mode line */
    3737  uppercase (DateMode);
    38   for (Ny = 0, c = strchr (DateMode, 'Y'); c != (char ) NULL; c = strchr (c + 1, 'Y'), Ny++);
     38  for (Ny = 0, c = strchr (DateMode, 'Y'); c != NULL; c = strchr (c + 1, 'Y'), Ny++);
    3939  if ((Ny != 2) && (Ny != 4)) {
    4040    fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode);
    … …  
    4444  pm = strchr (DateMode, 'M');
    4545  pd = strchr (DateMode, 'D');
    46   if ((py == (char *) NULL) || (pm == (char *) NULL) || (pd == (char *) NULL)) {
     46  if ((py == NULL) || (pm == NULL) || (pd == NULL)) {
    4747    fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode);
    4848    exit (0);
    … …  
    7070  warn_scan (header, DateKeyword, "%s",  1, line);
    7171  /* remove possible separators: ':', '/' '.', '-' */
    72   for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; }
    73   for (c = strchr (line, 0x2f); c != (char *) NULL; c = strchr (line, 0x2f)) { *c = ' '; }
    74   for (c = strchr (line, 0x2e); c != (char *) NULL; c = strchr (line, 0x2e)) { *c = ' '; }
    75   for (c = strchr (line, 0x2d); c != (char *) NULL; c = strchr (line, 0x2d)) { *c = ' '; }
     72  for (c = strchr (line, 0x3a); c != NULL; c = strchr (line, 0x3a)) { *c = ' '; }
     73  for (c = strchr (line, 0x2f); c != NULL; c = strchr (line, 0x2f)) { *c = ' '; }
     74  for (c = strchr (line, 0x2e); c != NULL; c = strchr (line, 0x2e)) { *c = ' '; }
     75  for (c = strchr (line, 0x2d); c != NULL; c = strchr (line, 0x2d)) { *c = ' '; }
    7676
    7777  Nf = 0;

  • trunk/Ohana/src/kapa2/src/LoadObject.c

    r17466 r20936  
    123123  }
    124124  if (Nbytes_send != Npts_send*sizeof(float)) {
    125     fprintf (stderr, "Kapa Communication error: unexpected data size %d vs %d\n", Nbytes_send, Npts_send*sizeof(float));
     125    fprintf (stderr, "Kapa Communication error: unexpected data size %d vs %ld\n", Nbytes_send, Npts_send*sizeof(float));
    126126  }
    127127

  • trunk/Ohana/src/kapa2/src/PaintOverlay.c

    r19939 r20936  
    55  int i;
    66  int dX, dY, dx, dy;
    7   int x, y, Xmin, Ymin, Xmax, Ymax, Xrange, Yrange;
     7  int Xmin, Ymin, Xmax, Ymax, Xrange, Yrange;
    88  double t, expand, X, Y, pX, pY;
    99 

  • trunk/Ohana/src/libautocode/def/common.h

    r15007 r20936  
    3838# endif
    3939
    40 # define e_time unsigned int
     40# define e_time int
    4141# define e_void long long
    4242# define rawshort short

  • trunk/Ohana/src/libautocode/def/image.d

    r20265 r20936  
    5050FIELD     ccdnum,           CCDNUM,               unsigned char,  CCD ID number
    5151FIELD     imageID,          IMAGE_ID,             unsigned int,   internal image ID
     52
     53# XXX do we want to use this to handle mosaics?
    5254# FIELD           parentID,         PARENT_ID,            unsigned int,   associated ref image
    5355FIELD     externID,         EXTERN_ID,            unsigned int,   external image ID

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

    r17190 r20936  
     1Image                   *Image_PS1_DEV_3_ToInternal (Image_PS1_DEV_3 *in, int Nvalues);
     2Image_PS1_DEV_3         *ImageInternalTo_PS1_DEV_3 (Image *in, int Nvalues);
     3
    14PhotCode *PhotCode_PS1_DEV_3_To_Internal (PhotCode_PS1_DEV_3 *in, int Nvalues);
    25PhotCode_PS1_DEV_3 *PhotCode_Internal_To_PS1_DEV_3 (PhotCode *in, int Nvalues);

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

    r17245 r20936  
    8888  catalog[0].secfilt = NULL;
    8989 
     90  catalog[0].objID = 0;
     91  catalog[0].catID = 0;
     92
    9093  catalog[0].Naverage = 0;
    9194  catalog[0].Nmeasure = 0;

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

    r15743 r20936  
    9494    gfits_modify (&catalog[0].header, "RA1",  "%lf", 1, region[0].Rmax);
    9595    gfits_modify (&catalog[0].header, "DEC1", "%lf", 1, region[0].Dmax);
     96   
     97    catalog[0].catID = region[0].index;
     98    gfits_modify (&catalog[0].header, "CATID", "%d", 1, catalog[0].catID);
    9699  }
    97100

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

    r15743 r20936  
    2727  if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &Nmissing)) return (FALSE);
    2828  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
     29
     30  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
     31     it is not defined for a legacy database, we can generate them using the existing index values.
     32     XXX if it is missing, give an error and require the user to upgrade the DB? */
     33  if (!gfits_scan (&catalog[0].header, "OBJID",    "%d", 1, &catalog[0].objID)) return (FALSE);
     34  if (!gfits_scan (&catalog[0].header, "CATID",    "%d", 1, &catalog[0].catID)) return (FALSE);
    2935
    3036  /* save the current number so we can do partial updates */
    … …  
    228234  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    229235  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     236  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    230237
    231238  f = catalog[0].f;

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

    r16810 r20936  
    2525  if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &catalog[0].Nmissing)) return (FALSE);
    2626  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
     27
     28  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
     29     it is not defined for a legacy database, we can generate them using the existing index values.
     30     XXX if it is missing, give an error and require the user to upgrade the DB? */
     31  if (!gfits_scan (&catalog[0].header, "OBJID",    "%d", 1, &catalog[0].objID)) return (FALSE);
     32  if (!gfits_scan (&catalog[0].header, "CATID",    "%d", 1, &catalog[0].catID)) return (FALSE);
    2733
    2834  /* determine catalog format */
    … …  
    249255  gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
    250256  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, catalog[0].Nsecfilt);
     257  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    251258
    252259  /* specify the appropriate data format */

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

    r17419 r20936  
    174174  if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &Nmissing)) return (FALSE);
    175175  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
     176
     177  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
     178     it is not defined for a legacy database, we can generate them using the existing index values.
     179     XXX if it is missing, give an error and require the user to upgrade the DB? */
     180  if (!gfits_scan (&catalog[0].header, "OBJID",    "%d", 1, &catalog[0].objID)) return (FALSE);
     181  if (!gfits_scan (&catalog[0].header, "CATID",    "%d", 1, &catalog[0].catID)) return (FALSE);
    176182
    177183  /* save the current number so we can do partial updates */
    … …  
    512518  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    513519  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     520  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    514521
    515522  /* in split mode, we can save only part of the data */
    … …  
    712719  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    713720  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     721  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    714722
    715723  /* in split mode, we can save only part of the data */
    … …  
    890898  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    891899  gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     900  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    892901
    893902  /* in split mode, we can save only part of the data */

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

    r17190 r20936  
    153153  skytable[0].Nregions = 0;
    154154
     155  // L0, L1, L2, L3, L4 all have index ranges of 0 -> Nregions and parent values pointing
     156  // at the index of the parent.  SkyTableAppend updates these values based on the
     157  // cumulative count
     158
    155159  SkyTableAppend (skytable, &L0, 0);
    156160  SkyTableAppend (skytable, &L1, skytable[0].Nregions - L0.Nregions);
    … …  
    539543  for (i = 0; i < new[0].Nregions; i++) {
    540544    old[0].regions[i + Nold] = new[0].regions[i];
    541     old[0].regions[i + Nold].parent += Nprev;
     545    old[0].regions[i + Nold].parent += Nold;
     546    old[0].regions[i + Nold].index += Nold;
    542547  }
    543548  return;
    … …  
    560565    notes and questions:
    561566    1) is the regions.index value used?
    562 
    563 
    564567***/

  • trunk/Ohana/src/libkapa/src/KiiPicture.c

    r19828 r20936  
    108108int KiiNewPicture2D (int fd, KiiImage *image, KapaImageData *data, Coords *coords) {
    109109
    110   int i, j;
    111   int Npix, Ncolors, NNcolors, size;
    112   float *in, min, max;
    113   char *out, *outbuffer;
    114   double a1, a2;
     110  int j;
     111  int Npix, Ncolors, size;
     112  float min, max;
    115113
    116114  Npix = image[0].Nx*image[0].Ny;

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

    r7080 r20936  
    3232  gfits_scan (header, UTKeyword, "%s", 1, line);
    3333  /* remove ':' characters */
    34   for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; }
     34  for (c = strchr (line, 0x3a); c != NULL; c = strchr (line, 0x3a)) { *c = ' '; }
    3535  sscanf (line, "%d %d %d", &hour, &min, &sec);
    3636
    3737  /* parse mode line */
    3838  uppercase (DateMode);
    39   for (Ny = 0, c = strchr (DateMode, 'Y'); c != (char ) NULL; c = strchr (c + 1, 'Y'), Ny++);
     39  for (Ny = 0, c = strchr (DateMode, 'Y'); c != NULL; c = strchr (c + 1, 'Y'), Ny++);
    4040  if ((Ny != 2) && (Ny != 4)) {
    4141    fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode);
    … …  
    4545  pm = strchr (DateMode, 'M');
    4646  pd = strchr (DateMode, 'D');
    47   if ((py == (char *) NULL) || (pm == (char *) NULL) || (pd == (char *) NULL)) {
     47  if ((py == NULL) || (pm == NULL) || (pd == NULL)) {
    4848    fprintf (stderr, "error in DATE-MODE format: %s\n", DateMode);
    4949    exit (1);
    … …  
    7171  gfits_scan (header, DateKeyword, "%s",  1, line);
    7272  /* remove possible separators: ':', '/' '.', '-' */
    73   for (c = strchr (line, 0x3a); c != (char *) NULL; c = strchr (line, 0x3a)) { *c = ' '; }
    74   for (c = strchr (line, 0x2f); c != (char *) NULL; c = strchr (line, 0x2f)) { *c = ' '; }
    75   for (c = strchr (line, 0x2e); c != (char *) NULL; c = strchr (line, 0x2e)) { *c = ' '; }
    76   for (c = strchr (line, 0x2d); c != (char *) NULL; c = strchr (line, 0x2d)) { *c = ' '; }
     73  for (c = strchr (line, 0x3a); c != NULL; c = strchr (line, 0x3a)) { *c = ' '; }
     74  for (c = strchr (line, 0x2f); c != NULL; c = strchr (line, 0x2f)) { *c = ' '; }
     75  for (c = strchr (line, 0x2e); c != NULL; c = strchr (line, 0x2e)) { *c = ' '; }
     76  for (c = strchr (line, 0x2d); c != NULL; c = strchr (line, 0x2d)) { *c = ' '; }
    7777
    7878  Nf = 0;

  • trunk/Ohana/src/opihi/cmd.astro/biassub.c

    r7917 r20936  
    55  int i, j, k, N, dir, nlong, nwide, start;
    66  int sx, sy, nx, ny, NX, NY, NoVector, Nval;
    7   float *V, *DV, dV, *vect, *segment, val;
     7  float *V, dV, *segment, val;
     8  opihi_flt *DV, *vect;
    89  Vector *xvec, *yvec;
    910  Buffer *buf;
    … …  
    5455  }
    5556
    56   ALLOCATE (vect, float, nlong);
     57  ALLOCATE (vect, opihi_flt, nlong);
    5758  ALLOCATE (segment, float, nwide);
    5859
    … …  
    9091
    9192  if (!NoVector) {
    92     xvec[0].Nelements = yvec[0].Nelements = nlong;
    93     REALLOCATE (xvec[0].elements, float, nlong);
    94     REALLOCATE (yvec[0].elements, float, nlong);
     93    ResetVector (xvec, OPIHI_FLT, nlong);
     94    ResetVector (yvec, OPIHI_FLT, nlong);
    9595    for (i = 0; i < nlong; i++) {
    96       xvec[0].elements[i] = i + start;
    97       yvec[0].elements[i] = vect[i];
     96      xvec[0].elements.Flt[i] = i + start;
     97      yvec[0].elements.Flt[i] = vect[i];
    9898    }
    9999  }

  • trunk/Ohana/src/opihi/cmd.astro/cgrid.c

    r13479 r20936  
    33  if (N == NELEMENTS) { \
    44    NELEMENTS +=200; \
    5     REALLOCATE (Xvec.elements, float, NELEMENTS); \
    6     REALLOCATE (Yvec.elements, float, NELEMENTS); \
     5    REALLOCATE (Xvec.elements.Flt, opihi_flt, NELEMENTS); \
     6    REALLOCATE (Yvec.elements.Flt, opihi_flt, NELEMENTS); \
    77  }
    88
    … …  
    9595 
    9696  /* prepare vectors to hold data */
     97  N = 0;
    9798  NELEMENTS = 200;
    98   ALLOCATE (Xvec.elements, float, NELEMENTS);
    99   ALLOCATE (Yvec.elements, float, NELEMENTS);
    100   N = 0;
     99  SetVector (&Xvec, OPIHI_FLT, NELEMENTS);
     100  SetVector (&Yvec, OPIHI_FLT, NELEMENTS);
    101101 
    102102  /***  do consecutive RA lines, first increasing **/
    … …  
    109109    for (d = firstDEC; (d < 90 + dD) && (LOnPic || NorthPole || SouthPole); d += dD) {
    110110      D = MAX (-90, MIN(90, d));
    111       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    112       /*
    113       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    114         First = TRUE;
    115         */
    116       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    117           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    118         N++;
    119         CHECKELEMENTS;
    120         OnPic = TRUE;
    121         if (!First) {
    122           Xvec.elements[N] = Xvec.elements[N-1];
    123           Yvec.elements[N] = Yvec.elements[N-1];
    124           N++;
    125           CHECKELEMENTS;
    126         } else {
    127           if (N > 1) {
    128             Xvec.elements[N-2] = Xvec.elements[N-1];
    129             Yvec.elements[N-2] = Yvec.elements[N-1];
     111      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     112      /*
     113      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     114        First = TRUE;
     115        */
     116      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     117          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     118        N++;
     119        CHECKELEMENTS;
     120        OnPic = TRUE;
     121        if (!First) {
     122          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     123          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     124          N++;
     125          CHECKELEMENTS;
     126        } else {
     127          if (N > 1) {
     128            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     129            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    130130            N--;
    131131          }
    … …  
    142142    for (d = firstDEC; (d > -90 - dD) && (LOnPic || NorthPole || SouthPole); d -= dD) {
    143143      D = MAX (-90, MIN(90, d));
    144       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    145       /*
    146       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    147         First = TRUE;
    148         */
    149       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    150           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    151         N++;
    152         CHECKELEMENTS;
    153         OnPic = TRUE;
    154         if (!First) {
    155           Xvec.elements[N] = Xvec.elements[N-1];
    156           Yvec.elements[N] = Yvec.elements[N-1];
    157           N++;
    158           CHECKELEMENTS;
    159         } else {
    160           if (N > 1) {
    161             Xvec.elements[N-2] = Xvec.elements[N-1];
    162             Yvec.elements[N-2] = Yvec.elements[N-1];
     144      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     145      /*
     146      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     147        First = TRUE;
     148        */
     149      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     150          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     151        N++;
     152        CHECKELEMENTS;
     153        OnPic = TRUE;
     154        if (!First) {
     155          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     156          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     157          N++;
     158          CHECKELEMENTS;
     159        } else {
     160          if (N > 1) {
     161            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     162            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    163163            N--;
    164164          }
    … …  
    181181    for (d = firstDEC; (d < 90 + dD) && (LOnPic || NorthPole || SouthPole); d += dD) {
    182182      D = MAX (-90, MIN(90, d));
    183       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    184       /*
    185       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    186         First = TRUE;
    187         */
    188       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    189           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    190         N++;
    191         CHECKELEMENTS;
    192         OnPic = TRUE;
    193         if (!First) {
    194           Xvec.elements[N] = Xvec.elements[N-1];
    195           Yvec.elements[N] = Yvec.elements[N-1];
    196           N++;
    197           CHECKELEMENTS;
    198         } else {
    199           if (N > 1) {
    200             Xvec.elements[N-2] = Xvec.elements[N-1];
    201             Yvec.elements[N-2] = Yvec.elements[N-1];
     183      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     184      /*
     185      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     186        First = TRUE;
     187        */
     188      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     189          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     190        N++;
     191        CHECKELEMENTS;
     192        OnPic = TRUE;
     193        if (!First) {
     194          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     195          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     196          N++;
     197          CHECKELEMENTS;
     198        } else {
     199          if (N > 1) {
     200            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     201            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    202202            N--;
    203203          }
    … …  
    214214    for (d = firstDEC; (d > -90 - dD) && (LOnPic || NorthPole || SouthPole); d -= dD) {
    215215      D = MAX (-90, MIN(90, d));
    216       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    217       /*
    218       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    219         First = TRUE;
    220         */
    221       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    222           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    223         N++;
    224         CHECKELEMENTS;
    225         OnPic = TRUE;
    226         if (!First) {
    227           Xvec.elements[N] = Xvec.elements[N-1];
    228           Yvec.elements[N] = Yvec.elements[N-1];
    229           N++;
    230           CHECKELEMENTS;
    231         } else {
    232           if (N > 1) {
    233             Xvec.elements[N-2] = Xvec.elements[N-1];
    234             Yvec.elements[N-2] = Yvec.elements[N-1];
     216      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     217      /*
     218      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     219        First = TRUE;
     220        */
     221      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     222          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     223        N++;
     224        CHECKELEMENTS;
     225        OnPic = TRUE;
     226        if (!First) {
     227          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     228          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     229          N++;
     230          CHECKELEMENTS;
     231        } else {
     232          if (N > 1) {
     233            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     234            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    235235            N--;
    236236          }
    … …  
    253253    First = TRUE;
    254254    for (r = firstRA; (r < firstRA + 180) && (LOnPic || NorthPole || SouthPole); r += dR) {
    255       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    256       /*
    257       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    258         First = TRUE;
    259         */
    260       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    261           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    262         N++;
    263         CHECKELEMENTS;
    264         OnPic = TRUE;
    265         if (!First) {
    266           Xvec.elements[N] = Xvec.elements[N-1];
    267           Yvec.elements[N] = Yvec.elements[N-1];
    268           N++;
    269           CHECKELEMENTS;
    270         } else {
    271           if (N > 1) {
    272             Xvec.elements[N-2] = Xvec.elements[N-1];
    273             Yvec.elements[N-2] = Yvec.elements[N-1];
     255      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     256      /*
     257      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     258        First = TRUE;
     259        */
     260      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     261          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     262        N++;
     263        CHECKELEMENTS;
     264        OnPic = TRUE;
     265        if (!First) {
     266          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     267          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     268          N++;
     269          CHECKELEMENTS;
     270        } else {
     271          if (N > 1) {
     272            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     273            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    274274            N--;
    275275          }
    … …  
    285285    LOnPic = TRUE;
    286286    for (r = firstRA; (r > firstRA - 180) && (LOnPic || NorthPole || SouthPole); r -= dR) {
    287       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    288       /*
    289       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    290         First = TRUE;
    291         */
    292       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    293           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    294         N++;
    295         CHECKELEMENTS;
    296         OnPic = TRUE;
    297         if (!First) {
    298           Xvec.elements[N] = Xvec.elements[N-1];
    299           Yvec.elements[N] = Yvec.elements[N-1];
    300           N++;
    301           CHECKELEMENTS;
    302         } else {
    303           if (N > 1) {
    304             Xvec.elements[N-2] = Xvec.elements[N-1];
    305             Yvec.elements[N-2] = Yvec.elements[N-1];
     287      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     288      /*
     289      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     290        First = TRUE;
     291        */
     292      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     293          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     294        N++;
     295        CHECKELEMENTS;
     296        OnPic = TRUE;
     297        if (!First) {
     298          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     299          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     300          N++;
     301          CHECKELEMENTS;
     302        } else {
     303          if (N > 1) {
     304            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     305            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    306306            N--;
    307307          }
    … …  
    324324    First = TRUE;
    325325    for (r = firstRA; (r < firstRA + 180) && (LOnPic || NorthPole || SouthPole); r += dR) {
    326       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    327       /*
    328       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    329         First = TRUE;
    330         */
    331       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    332           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    333         N++;
    334         CHECKELEMENTS;
    335         OnPic = TRUE;
    336         if (!First) {
    337           Xvec.elements[N] = Xvec.elements[N-1];
    338           Yvec.elements[N] = Yvec.elements[N-1];
    339           N++;
    340           CHECKELEMENTS;
    341         } else {
    342           if (N > 1) {
    343             Xvec.elements[N-2] = Xvec.elements[N-1];
    344             Yvec.elements[N-2] = Yvec.elements[N-1];
     326      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     327      /*
     328      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     329        First = TRUE;
     330        */
     331      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     332          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     333        N++;
     334        CHECKELEMENTS;
     335        OnPic = TRUE;
     336        if (!First) {
     337          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     338          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     339          N++;
     340          CHECKELEMENTS;
     341        } else {
     342          if (N > 1) {
     343            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     344            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    345345            N--;
    346346          }
    … …  
    356356    LOnPic = TRUE;
    357357    for (r = firstRA; (r > firstRA - 180) && (LOnPic || NorthPole || SouthPole); r -= dR) {
    358       status = fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, D, &graphmode.coords);
    359       /*
    360       if ((fabs(Xvec.elements[N] - Xvec.elements[N-1]) > 10) && (fabs(Yvec.elements[N] - Yvec.elements[N-1]) > 10))
    361         First = TRUE;
    362         */
    363       if ((Xvec.elements[N] >= graphmode.xmin) && (Xvec.elements[N] <= graphmode.xmax) &&
    364           (Yvec.elements[N] >= graphmode.ymin) && (Yvec.elements[N] <= graphmode.ymax) && status) {
    365         N++;
    366         CHECKELEMENTS;
    367         OnPic = TRUE;
    368         if (!First) {
    369           Xvec.elements[N] = Xvec.elements[N-1];
    370           Yvec.elements[N] = Yvec.elements[N-1];
    371           N++;
    372           CHECKELEMENTS;
    373         } else {
    374           if (N > 1) {
    375             Xvec.elements[N-2] = Xvec.elements[N-1];
    376             Yvec.elements[N-2] = Yvec.elements[N-1];
     358      status = RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, D, &graphmode.coords);
     359      /*
     360      if ((fabs(Xvec.elements.Flt[N] - Xvec.elements.Flt[N-1]) > 10) && (fabs(Yvec.elements.Flt[N] - Yvec.elements.Flt[N-1]) > 10))
     361        First = TRUE;
     362        */
     363      if ((Xvec.elements.Flt[N] >= graphmode.xmin) && (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     364          (Yvec.elements.Flt[N] >= graphmode.ymin) && (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
     365        N++;
     366        CHECKELEMENTS;
     367        OnPic = TRUE;
     368        if (!First) {
     369          Xvec.elements.Flt[N] = Xvec.elements.Flt[N-1];
     370          Yvec.elements.Flt[N] = Yvec.elements.Flt[N-1];
     371          N++;
     372          CHECKELEMENTS;
     373        } else {
     374          if (N > 1) {
     375            Xvec.elements.Flt[N-2] = Xvec.elements.Flt[N-1];
     376            Yvec.elements.Flt[N-2] = Yvec.elements.Flt[N-1];
    377377            N--;
    378378          }
    … …  
    391391  graphmode.ptype = 100; /* connect a pair */
    392392  graphmode.etype = 0;
    393   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
    394 
    395   free (Xvec.elements);
    396   free (Yvec.elements);
     393  PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
     394
     395  free (Xvec.elements.Ptr);
     396  free (Yvec.elements.Ptr);
    397397  return (TRUE);
    398398

  • trunk/Ohana/src/opihi/cmd.astro/coords.c

    r17484 r20936  
    5656      return (FALSE);
    5757    }
     58    REQUIRE_VECTOR_FLT (xvec, FALSE);
     59    REQUIRE_VECTOR_FLT (yvec, FALSE);
    5860    form = VECTOR;
    5961  }     
    … …  
    8991  if (mode == SKY) {
    9092    for (i = 0; i < xvec[0].Nelements; i++) {
    91       fXY_to_RD (&xvec[0].elements[i], &yvec[0].elements[i], xvec[0].elements[i], yvec[0].elements[i], &coords);
     93      XY_to_RD (&xvec[0].elements.Flt[i], &yvec[0].elements.Flt[i], xvec[0].elements.Flt[i], yvec[0].elements.Flt[i], &coords);
    9294    }
    9395    return (TRUE);
    … …  
    9597  if (mode == PIXEL) {
    9698    for (i = 0; i < xvec[0].Nelements; i++) {
    97       fRD_to_XY (&xvec[0].elements[i], &yvec[0].elements[i], xvec[0].elements[i], yvec[0].elements[i], &coords);
     99      RD_to_XY (&xvec[0].elements.Flt[i], &yvec[0].elements.Flt[i], xvec[0].elements.Flt[i], yvec[0].elements.Flt[i], &coords);
    98100    }
    99101    return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/cplot.c

    r19823 r20936  
    44 
    55  int i, kapa, Npts, status, leftside;
    6   float *x, *y, *r, *d, Rmin, Rmax, Rmid;
     6  opihi_flt *x, *y, *r, *d, Rmin, Rmax, Rmid;
    77  Vector Xvec, Yvec, *xvec, *yvec;
    88  Graphdata graphmode;
    … …  
    2323  if ((yvec = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2424
     25  REQUIRE_VECTOR_FLT (xvec, FALSE);
     26  REQUIRE_VECTOR_FLT (yvec, FALSE);
     27
    2528  if (xvec[0].Nelements != yvec[0].Nelements) {
    2629    gprint (GP_ERR, "vectors are not the same length\n");
    … …  
    2831  }
    2932
    30   ALLOCATE (Xvec.elements, float, xvec[0].Nelements);
    31   ALLOCATE (Yvec.elements, float, xvec[0].Nelements);
    32    
    33   Xvec.Nelements = xvec[0].Nelements;
    34   Yvec.Nelements = xvec[0].Nelements;
     33  SetVector (&Xvec, OPIHI_FLT, xvec[0].Nelements);
     34  SetVector (&Yvec, OPIHI_FLT, xvec[0].Nelements);
    3535 
    36   r = xvec[0].elements;
    37   d = yvec[0].elements;
    38   x = Xvec.elements;
    39   y = Yvec.elements;
     36  r = xvec[0].elements.Flt;
     37  d = yvec[0].elements.Flt;
     38  x = Xvec.elements.Flt;
     39  y = Yvec.elements.Flt;
    4040 
    4141  Npts = 0;
    4242  for (i = 0; i < Xvec.Nelements; i++, r++, d++) {
    43       *r = ohana_normalize_angle (*r);
     43    *r = ohana_normalize_angle (*r);
    4444    while (*r < Rmin) *r += 360.0;
    4545    while (*r > Rmax) *r -= 360.0;
    … …  
    5151      if (!leftside && (r[0] < Rmid - 90)) { r[0] += 360.0; }
    5252    }
    53     status = fRD_to_XY (x, y, *r, *d, &graphmode.coords);
     53    status = RD_to_XY (x, y, *r, *d, &graphmode.coords);
    5454
    5555    // if we fail on one of the points, drop the corresponding pair
    … …  
    7777
    7878  graphmode.etype = 0;
    79   PlotVectorPair (kapa, Npts, Xvec.elements, Yvec.elements, &graphmode);
     79  PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    8080 
    81   free (Xvec.elements);
    82   free (Yvec.elements);
     81  free (Xvec.elements.Ptr);
     82  free (Yvec.elements.Ptr);
    8383   
    8484  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/csystem.c

    r16935 r20936  
    66  int i;
    77  double X, Y, x, y;
    8   float *xptr, *yptr;
     8  opihi_flt *xptr, *yptr;
    99  Vector *xvec, *yvec;
    1010  CoordTransformSystem input, output;
    … …  
    5454  }
    5555 
    56   xptr = xvec[0].elements;
    57   yptr = yvec[0].elements;
     56  CastVector (xvec, OPIHI_FLT);
     57  CastVector (yvec, OPIHI_FLT);
     58
     59  xptr = xvec[0].elements.Flt;
     60  yptr = yvec[0].elements.Flt;
    5861
    5962  for (i = 0; i < xvec[0].Nelements; i++, xptr++, yptr++) {
    60     // ApplyTransform takes (double *), but xptr, yptr are (float *)
    61     ApplyTransform (&x, &y, *xptr, *yptr, transform);
    62     *xptr = x;
    63     *yptr = y;
     63    ApplyTransform (xptr, yptr, *xptr, *yptr, transform);
    6464  }
    6565

  • trunk/Ohana/src/opihi/cmd.astro/czplot.c

    r19823 r20936  
    33int czplot (int argc, char **argv) {
    44 
    5   int i, kapa, Npts;
     5  int i, kapa;
    66  double min, range, Rmin, Rmax;
    7   float *in, *out, *r, *d, *x, *y;
     7  opihi_flt *out, *r, *d, *x, *y;
    88  Vector Xvec, Yvec, Zvec, *xvec, *yvec, *zvec;
    99  Graphdata graphmode;
    … …  
    2626  if ((zvec = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2727
     28  REQUIRE_VECTOR_FLT (xvec, FALSE);
     29  REQUIRE_VECTOR_FLT (yvec, FALSE);
     30  REQUIRE_VECTOR_FLT (zvec, FALSE);
     31
    2832  if (xvec[0].Nelements != yvec[0].Nelements) {
    2933    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[1], argv[2]);
    … …  
    3438    return (FALSE);
    3539  }
    36   Xvec.Nelements = xvec[0].Nelements;
    37   Yvec.Nelements = xvec[0].Nelements;
    38   Zvec.Nelements = zvec[0].Nelements;
    39   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    40   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
    41   ALLOCATE (Zvec.elements, float, Zvec.Nelements);
     40  SetVector (&Xvec, OPIHI_FLT, xvec[0].Nelements);
     41  SetVector (&Yvec, OPIHI_FLT, xvec[0].Nelements);
     42  SetVector (&Zvec, OPIHI_FLT, xvec[0].Nelements);
    4243 
    43   r   = xvec[0].elements;
    44   d   = yvec[0].elements;
    45   in  = zvec[0].elements;
    46   x   = Xvec.elements;
    47   y   = Yvec.elements;
    48   out = Zvec.elements;
    49   for (i = 0; i < Zvec.Nelements; i++, in++, out++, r++, d++, x++, y++) {
    50     *out = MIN (1.0, MAX (0.01, (*in - min) / range));
     44  r   = xvec[0].elements.Flt;
     45  d   = yvec[0].elements.Flt;
     46  x   = Xvec.elements.Flt;
     47  y   = Yvec.elements.Flt;
     48  for (i = 0; i < Zvec.Nelements; i++, r++, d++, x++, y++) {
    5149    *r = ohana_normalize_angle (*r);
    52     fRD_to_XY (x, y, *r, *d, &graphmode.coords);
     50    RD_to_XY (x, y, *r, *d, &graphmode.coords);
     51  }
     52
     53  out = Zvec.elements.Flt;
     54  if (zvec->type == OPIHI_FLT) {
     55    opihi_flt *in  = zvec[0].elements.Flt;
     56    for (i = 0; i < Zvec.Nelements; i++, in++, out++) {
     57      *out = MIN (1.0, MAX (0.01, (*in - min) / range));
     58    }
     59  } else {
     60    opihi_int *in  = zvec[0].elements.Int;
     61    for (i = 0; i < Zvec.Nelements; i++, in++, out++) {
     62      *out = MIN (1.0, MAX (0.01, (*in - min) / range));
     63    }
    5364  }
    5465
    … …  
    5667  graphmode.size = -1; /* point size determined by Zvec */
    5768  graphmode.etype = 0;
    58   Npts = Xvec.Nelements;
    59   PlotVectorTriplet (kapa, Npts, Xvec.elements, Yvec.elements, Zvec.elements, &graphmode);
     69  PlotVectorTriplet (kapa, &Xvec, &Yvec, &Zvec, &graphmode);
    6070
    61   free (Xvec.elements);
    62   free (Yvec.elements);
    63   free (Zvec.elements);
     71  free (Xvec.elements.Flt);
     72  free (Yvec.elements.Flt);
     73  free (Zvec.elements.Flt);
    6474
    6575  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/imfit-fgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float fgaussTD (float, float, float *, int, float *);
     3opihi_flt fgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  fgaussCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0);
    … …  
    4040
    4141/* real 2D gaussian -- x, y, sx, sy, sxy, I, sky */
    42 float fgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     42opihi_flt fgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4343
    44   float X, Y, px, py;
    45   float z, r, q, f;
     44  opihi_flt X, Y, px, py;
     45  opihi_flt z, r, q, f;
    4646
    4747  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-pgauss-psf.c

    r12840 r20936  
    11# include "imfit.h"
    22
    3 float pgauss_psfTD (float, float, float *, int, float *);
     3opihi_flt pgauss_psfTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  pgauss_psfCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0);
    … …  
    3838
    3939/* pseudo 2D gaussian -- x, y, (sx), (sy), (sxy), I, sky */
    40 float pgauss_psfTD (float x, float y, float *par, int Npar, float *dpar) {
     40opihi_flt pgauss_psfTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4141
    42   float X, Y, px, py;
    43   float z, r, q, f;
     42  opihi_flt X, Y, px, py;
     43  opihi_flt z, r, q, f;
    4444
    4545  /* par -> fpar: (2,0), (3,1), (4,2) */

  • trunk/Ohana/src/opihi/cmd.astro/imfit-pgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float pgaussTD (float, float, float *, int, float *);
     3opihi_flt pgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  pgaussCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0.0);
    … …  
    4040
    4141/* pseudo 2D gaussian -- x, y, sx, sy, sxy, I, sky */
    42 float pgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     42opihi_flt pgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4343
    44   float X, Y, px, py;
    45   float z, r, q, f;
     44  opihi_flt X, Y, px, py;
     45  opihi_flt z, r, q, f;
    4646
    4747  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-qfgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float qfgaussTD (float, float, float *, int, float *);
     3opihi_flt qfgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  qfgaussCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0]  = get_variable_default ("Xg", 0);
    … …  
    4444
    4545/* one component, two slopes: (1 + z^M + z^N)^(-1) -- x, y, sx, sy, sxy, I, sky */
    46 float qfgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     46opihi_flt qfgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4747
    48   float X, Y, px, py;
    49   float z, r, q, f;
     48  opihi_flt X, Y, px, py;
     49  opihi_flt z, r, q, f;
    5050
    5151  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-qgauss-psf.c

    r12840 r20936  
    11# include "imfit.h"
    22
    3 float qgauss_psfTD (float, float, float *, int, float *);
     3opihi_flt qgauss_psfTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  qgauss_psfCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0]  = get_variable_default ("Xg", 0);
    … …  
    4141
    4242/* one component, two slopes: (1 + z^M + z^N)^(-1) -- x, y, sx, sy, sxy, I, sky, sr */
    43 float qgauss_psfTD (float x, float y, float *par, int Npar, float *dpar) {
     43opihi_flt qgauss_psfTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4444
    45   float X, Y, px, py;
    46   float z, r, q, f;
     45  opihi_flt X, Y, px, py;
     46  opihi_flt z, r, q, f;
    4747
    4848  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-qgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float qgaussTD (float, float, float *, int, float *);
     3opihi_flt qgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  qgaussCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0]  = get_variable_default ("Xg", 0);
    … …  
    4444
    4545/* one component, two slopes: (1 + z^M + z^N)^(-1) -- x, y, sx, sy, sxy, I, sky, sr */
    46 float qgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     46opihi_flt qgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4747
    48   float X, Y, px, py;
    49   float z, r, q, f;
     48  opihi_flt X, Y, px, py;
     49  opihi_flt z, r, q, f;
    5050
    5151  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-qrgauss.c

    r4420 r20936  
    11# include "imfit.h"
    22
    3 float qrgaussTD (float, float, float *, int, float *);
     3opihi_flt qrgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  qrgaussCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0]  = get_variable_default ("Xg", 0);
    … …  
    4444}
    4545
    46 float qrgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     46opihi_flt qrgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4747
    48   float X, Y, px, py;
    49   float z, r, q, f;
     48  opihi_flt X, Y, px, py;
     49  opihi_flt z, r, q, f;
    5050
    5151  X = x - par[0];
    … …  
    7777# if (0)
    7878/* one component, two slopes: (1 + z^M + z^N)^(-1) -- x, y, sx, sy, sxy, I, sky, sr */
    79 float qrgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     79opihi_flt qrgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    8080
    81   float X, Y, px, py;
    82   float z, r, q, f;
     81  opihi_flt X, Y, px, py;
     82  opihi_flt z, r, q, f;
    8383
    8484  /* if (par[7] < 1.0) par[7] = 1.0; */

  • trunk/Ohana/src/opihi/cmd.astro/imfit-rgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float rgaussTD (float, float, float *, int, float *);
     3opihi_flt rgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  rgaussCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0);
    … …  
    3636
    3737/* two components: (1 + z_1 + 0.5*z_1^2 + z_2^N)^(-1) -- x, y, sx1, sy1, sxy1, I, sky, sx2, sy2, sxy2 */
    38 float rgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     38opihi_flt rgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    3939
    40   float X, Y, px1, py1, px2, py2;
    41   float z1, z2, r, q1, q2, f;
     40  opihi_flt X, Y, px1, py1, px2, py2;
     41  opihi_flt z1, z2, r, q1, q2, f;
    4242
    4343  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-serbulge.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float serbulgeTD (float, float, float *, int, float *);
     3opihi_flt serbulgeTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  serbulgeCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0);
    … …  
    4141/* sersic galaxy model w/ bulge: -- x, y, (sx, sy, sxy)_1, I_1, sky, (sx, sy, sxy)_2, I_2, n */
    4242/* exp (-b (r/r_e)^(1/n)) + pgauss (r) */
    43 float serbulgeTD (float x, float y, float *par, int Npar, float *dpar) {
     43opihi_flt serbulgeTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4444
    45   float X, Y, px1, px2, py1, py2;
    46   float z1, z2, r1, r2, t, q1, q2, f;
     45  opihi_flt X, Y, px1, px2, py1, py2;
     46  opihi_flt z1, z2, r1, r2, t, q1, q2, f;
    4747
    4848  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-sersic.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float sersicTD (float, float, float *, int, float *);
     3opihi_flt sersicTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  sersicCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0);
    … …  
    3333/* sersic galaxy model -- x, y, sx, sy, sxy, I, sky, n */
    3434/* exp (-b (r/r_e)^(1/n)) */
    35 float sersicTD (float x, float y, float *par, int Npar, float *dpar) {
     35opihi_flt sersicTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    3636
    37   float X, Y, px, py;
    38   float z, r, t, q, f;
     37  opihi_flt X, Y, px, py;
     38  opihi_flt z, r, t, q, f;
    3939
    4040  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-sgauss-psf.c

    r12840 r20936  
    11# include "imfit.h"
    22
    3 float sgauss_psfTD (float, float, float *, int, float *);
     3opihi_flt sgauss_psfTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  sgauss_psfCL ();
    55
    … …  
    1414
    1515  /* allocate free and fixed parameters */
    16   ALLOCATE (par, float, MAX (Npar, 1));
    17   bzero (par, Npar*sizeof(float));
    18   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    19   bzero (fpar, Nfpar*sizeof(float));
     16  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     17  bzero (par, Npar*sizeof(opihi_flt));
     18  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     19  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2020
    2121  par[0] = get_variable_default ("Xg", 0);
    … …  
    4343
    4444/* two components: (1 + z_1 + z_2^N)^(-1) -- x, y, sx1, sy1, sxy1, I, sky, sx2, sy2, sxy2 */
    45 float sgauss_psfTD (float x, float y, float *par, int Npar, float *dpar) {
     45opihi_flt sgauss_psfTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    4646
    47   float X, Y, px1, py1, px2, py2;
    48   float z1, z2, r, q1, q2, f;
     47  opihi_flt X, Y, px1, py1, px2, py2;
     48  opihi_flt z1, z2, r, q1, q2, f;
    4949
    5050  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-sgauss.c

    r3144 r20936  
    33# define FSCALE 1.2
    44
    5 float sgaussTD (float, float, float *, int, float *);
     5opihi_flt sgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    66void  sgaussCL ();
    77
    … …  
    1616
    1717  /* allocate free and fixed parameters */
    18   ALLOCATE (par, float, MAX (Npar, 1));
    19   bzero (par, Npar*sizeof(float));
    20   ALLOCATE (fpar, float, MAX (Nfpar, 1));
    21   bzero (fpar, Nfpar*sizeof(float));
     18  ALLOCATE (par, opihi_flt, MAX (Npar, 1));
     19  bzero (par, Npar*sizeof(opihi_flt));
     20  ALLOCATE (fpar, opihi_flt, MAX (Nfpar, 1));
     21  bzero (fpar, Nfpar*sizeof(opihi_flt));
    2222
    2323  par[0] = get_variable_default ("Xg", 0);
    … …  
    5252
    5353/* two components: (1 + z_1 + z_2^N)^(-1) -- x, y, sx1, sy1, sxy1, I, sky, sx2, sy2, sxy2 */
    54 float sgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     54opihi_flt sgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    5555
    56   float X, Y, px1, py1, px2, py2;
    57   float z1, z2, r, q1, q2, f, f1, f2;
     56  opihi_flt X, Y, px1, py1, px2, py2;
     57  opihi_flt z1, z2, r, q1, q2, f, f1, f2;
    5858
    5959  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-tgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float tgaussTD (float, float, float *, int, float *);
     3opihi_flt tgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  tgaussCL ();
    55
    … …  
    3131
    3232/* two components: (1 + z_1^M + z_2^N)^(-1) -- x, y, sx1, sy1, sxy1, I, sky, sx2, sy2, sxy2 */
    33 float tgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     33opihi_flt tgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    3434
    35   float X, Y, px1, py1, px2, py2;
    36   float z1, z2, r, q1, q2, f;
     35  opihi_flt X, Y, px1, py1, px2, py2;
     36  opihi_flt z1, z2, r, q1, q2, f;
    3737
    3838  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit-vgauss.c

    r3144 r20936  
    11# include "imfit.h"
    22
    3 float vgaussTD (float, float, float *, int, float *);
     3opihi_flt vgaussTD (opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    44void  vgaussCL ();
    55
    … …  
    2525}
    2626
    27 /* pseudo 2D gaussian with floating 2nd and 3rd order terms -- x, y, sx, sy, sxy, I, sky, f1, f2 */
    28 float vgaussTD (float x, float y, float *par, int Npar, float *dpar) {
     27/* pseudo 2D gaussian with opihi_flting 2nd and 3rd order terms -- x, y, sx, sy, sxy, I, sky, f1, f2 */
     28opihi_flt vgaussTD (opihi_flt x, opihi_flt y, opihi_flt *par, int Npar, opihi_flt *dpar) {
    2929
    30   float X, Y, px, py;
    31   float z, r, q, f, k;
     30  opihi_flt X, Y, px, py;
     31  opihi_flt z, r, q, f, k;
    3232
    3333  X = x - par[0];

  • trunk/Ohana/src/opihi/cmd.astro/imfit.c

    r12840 r20936  
    66  int sx, sy, nx, ny, Nx, Ny;
    77  float chisq, ochisq, dchisq, Gain, RDnoise, SatThreshold;
    8   float *x, *y, *z, *dz, *V;
     8  opihi_flt *x, *y, *z, *dz;
     9  float *V;
    910  Buffer *buf;
    1011
    … …  
    9495  N = 0;
    9596  Npts = nx*ny;
    96   ALLOCATE (x,  float, 2*Npts);
    97   ALLOCATE (y,  float, 2*Npts);
    98   ALLOCATE (z,  float, 2*Npts);
    99   ALLOCATE (dz, float, 2*Npts);
     97  ALLOCATE (x,  opihi_flt, 2*Npts);
     98  ALLOCATE (y,  opihi_flt, 2*Npts);
     99  ALLOCATE (z,  opihi_flt, 2*Npts);
     100  ALLOCATE (dz, opihi_flt, 2*Npts);
    100101  for (j = 0; j < ny; j++) {
    101102    if (j + sy < 0) continue;

  • trunk/Ohana/src/opihi/cmd.astro/multifit.c

    r16059 r20936  
    4646    sprintf (name, "c%d", i);
    4747    if ((Nc[i]  = SelectVector (name, ANYVECTOR, TRUE)) == NULL) goto escape;
     48    ResetVector (Nc[i], OPIHI_FLT, 1);
    4849    sprintf (name, "Mb%d", i);
    4950    if ((NMb[i] = SelectVector (name, OLDVECTOR, TRUE)) == NULL) goto escape;
     51    REQUIRE_VECTOR_FLT (NMb[i], FALSE);
    5052    sprintf (name, "mb%d", i);
    5153    if ((Nmb[i] = SelectVector (name, OLDVECTOR, TRUE)) == NULL) goto escape;
     54    REQUIRE_VECTOR_FLT (Nmb[i], FALSE);
    5255    sprintf (name, "wb%d", i);
    5356    if ((Nwb[i] = SelectVector (name, OLDVECTOR, TRUE)) == NULL) goto escape;
     57    REQUIRE_VECTOR_FLT (Nwb[i], FALSE);
    5458  }
    5559  for (i = 0; i < Norder - 1; i++) {
    5660    sprintf (name, "ml%d", i);
    5761    if ((Nml[i] = SelectVector (name, OLDVECTOR, TRUE)) == NULL) goto escape;
     62    REQUIRE_VECTOR_FLT (Nml[i], FALSE);
    5863    sprintf (name, "mh%d", i);
    5964    if ((Nmh[i] = SelectVector (name, OLDVECTOR, TRUE)) == NULL) goto escape;
     65    REQUIRE_VECTOR_FLT (Nmh[i], FALSE);
    6066    sprintf (name, "wo%d", i);
    6167    if ((Nwo[i] = SelectVector (name, OLDVECTOR, TRUE)) == NULL) goto escape;
     68    REQUIRE_VECTOR_FLT (Nwo[i], FALSE);
    6269  }
    6370
    … …  
    7279            v = 0;
    7380            for (n = 0; n < Nwo[i-1][0].Nelements; n++) {
    74               v += -pow (Nwo[i-1][0].elements[n], (double)(j+J));
     81              v += -pow (Nwo[i-1][0].elements.Flt[n], (double)(j+J));
    7582            }
    7683            a[Ny][Nx] = v;
    … …  
    8390            v = 0;
    8491            for (n = 0; n < Nwo[i][0].Nelements; n++) {
    85               v += -pow (Nwo[i][0].elements[n], (double)(j+J));
     92              v += -pow (Nwo[i][0].elements.Flt[n], (double)(j+J));
    8693            }
    8794            a[Ny][Nx] = v;
    … …  
    94101            v = 0;
    95102            for (n = 0; n < Nwb[i][0].Nelements; n++) {
    96               v += pow (Nwb[i][0].elements[n], (double)(j+J));
     103              v += pow (Nwb[i][0].elements.Flt[n], (double)(j+J));
    97104            }
    98105            if (i > 0) {
    99106              for (n = 0; n < Nwo[i-1][0].Nelements; n++) {
    100                 v += pow (Nwo[i-1][0].elements[n], (double)(j+J));
     107                v += pow (Nwo[i-1][0].elements.Flt[n], (double)(j+J));
    101108              }
    102109            }
    103110            if (i < Norder - 1) {
    104111              for (n = 0; n < Nwo[i][0].Nelements; n++) {
    105                 v += pow (Nwo[i][0].elements[n], (double)(j+J));
     112                v += pow (Nwo[i][0].elements.Flt[n], (double)(j+J));
    106113              }
    107114            }
    … …  
    123130      v = 0;
    124131      for (n = 0; n < Nwb[i][0].Nelements; n++) {
    125         v += NMb[i][0].elements[n]*pow (Nwb[i][0].elements[n], (double)j);
    126         v -= Nmb[i][0].elements[n]*pow (Nwb[i][0].elements[n], (double)j);
     132        v += NMb[i][0].elements.Flt[n]*pow (Nwb[i][0].elements.Flt[n], (double)j);
     133        v -= Nmb[i][0].elements.Flt[n]*pow (Nwb[i][0].elements.Flt[n], (double)j);
    127134      }
    128135      if (i > 0) {
    129136        for (n = 0; n < Nwo[i-1][0].Nelements; n++) {
    130           v += Nmh[i-1][0].elements[n] * pow (Nwo[i-1][0].elements[n], (double)j);
    131           v -= Nml[i-1][0].elements[n] * pow (Nwo[i-1][0].elements[n], (double)j);
     137          v += Nmh[i-1][0].elements.Flt[n] * pow (Nwo[i-1][0].elements.Flt[n], (double)j);
     138          v -= Nml[i-1][0].elements.Flt[n] * pow (Nwo[i-1][0].elements.Flt[n], (double)j);
    132139        }
    133140      }
    134141      if (i < Norder - 1) {
    135142        for (n = 0; n < Nwo[i][0].Nelements; n++) {
    136           v += Nml[i][0].elements[n] * pow (Nwo[i][0].elements[n], (double)j);
    137           v -= Nmh[i][0].elements[n] * pow (Nwo[i][0].elements[n], (double)j);
     143          v += Nml[i][0].elements.Flt[n] * pow (Nwo[i][0].elements.Flt[n], (double)j);
     144          v -= Nmh[i][0].elements.Flt[n] * pow (Nwo[i][0].elements.Flt[n], (double)j);
    138145        }
    139146      }
    … …  
    146153  for (i = 0; i < Norder; i++) {
    147154    Nc[i][0].Nelements = nterm[i];
    148     REALLOCATE (Nc[i][0].elements, float, nterm[i]);
     155    REALLOCATE (Nc[i][0].elements.Flt, opihi_flt, nterm[i]);
    149156    for (j = 0; j < nterm[i]; j++, Ny++) {
    150       Nc[i][0].elements[j] = b[Ny][0];
     157      Nc[i][0].elements.Flt[j] = b[Ny][0];
    151158    }
    152159  }

  • trunk/Ohana/src/opihi/cmd.astro/precess.c

    r7917 r20936  
    9090  }
    9191 
    92   for (i = 0; i < xvec[0].Nelements; i++) {
    93     A = xvec[0].elements[i];
    94     D = yvec[0].elements[i];
     92  // cast xvec or yvec to FLT if it is type INT
     93  CastVector (xvec, OPIHI_FLT);
     94  CastVector (yvec, OPIHI_FLT);
     95
     96  opihi_flt *Av = xvec[0].elements.Flt;
     97  opihi_flt *Dv = yvec[0].elements.Flt;
     98
     99  for (i = 0; i < xvec[0].Nelements; i++, Av, Dv) {
     100    A = *Av;
     101    D = *Dv;
    95102    SD =  cos(RAD_DEG*A + zeta)*sin(theta)*cos(RAD_DEG*D) + cos(theta)*sin(RAD_DEG*D);
    96103    CD = sqrt (1 - SD*SD);
    … …  
    101108    RA  = DEG_RAD*atan2(SA, CA) + z;
    102109
    103     if (RA < 0)
    104       RA += 360;
     110    if (RA < 0) RA += 360;
    105111   
    106     xvec[0].elements[i] = RA;
    107     yvec[0].elements[i] = DEC;
     112    *Av = RA;
     113    *Dv = DEC;
    108114  }
    109115

  • trunk/Ohana/src/opihi/cmd.astro/profile.c

    r7917 r20936  
    2828  if ((yvec = SelectVector (argv[3], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    2929
    30   xvec[0].Nelements = yvec[0].Nelements = (int)SQ(2*N+1);
    31   REALLOCATE (xvec[0].elements, float, 5*(int)SQ(2*N+1));
    32   REALLOCATE (yvec[0].elements, float, 5*(int)SQ(2*N+1));
    33   bzero (yvec[0].elements, (int)SQ(2*N+1)*sizeof(float)+1);
     30  ResetVector (xvec, OPIHI_FLT, (int)SQ(2*N+1));
     31  ResetVector (yvec, OPIHI_FLT, (int)SQ(2*N+1));
     32
     33  bzero (yvec[0].elements.Flt, (int)SQ(2*N+1)*sizeof(opihi_flt)+1);
    3434  V = (float *)(buf[0].matrix.buffer);
    3535  Npt = 0;
    … …  
    3737  for (i = sx - N; i < sx + N; i++) {
    3838    for (j = sy - N; j < sy + N; j++, Npt++) {
    39       yvec[0].elements[Npt] = V[i + j*Nx];
    40       xvec[0].elements[Npt] = hypot (i - sx, j - sy);
     39      yvec[0].elements.Flt[Npt] = V[i + j*Nx];
     40      xvec[0].elements.Flt[Npt] = hypot (i - sx, j - sy);
    4141    }
    4242  }
    4343
    44   fsortpair (xvec[0].elements, yvec[0].elements, xvec[0].Nelements);
     44  dsortpair (xvec[0].elements.Flt, yvec[0].elements.Flt, xvec[0].Nelements);
    4545
    4646  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.astro/spec.c

    r7917 r20936  
    5555
    5656  N = y2 - y1;
    57   REALLOCATE (xvec[0].elements, float, N);
    58   REALLOCATE (yvec[0].elements, float, N);
    59   xvec[0].Nelements = N;
    60   yvec[0].Nelements = N;
     57  ResetVector (xvec, OPIHI_FLT, N);
     58  ResetVector (yvec, OPIHI_FLT, N);
    6159 
    6260  ALLOCATE (buffer, float, Nlong);
    … …  
    103101      R += 1.0 / sky2;
    104102    }
    105     xvec[0].elements[j] = j + y1;
    106     yvec[0].elements[j] = F / R;
     103    xvec[0].elements.Flt[j] = j + y1;
     104    yvec[0].elements.Flt[j] = F / R;
    107105    gprint (GP_ERR, " %5.1f %7.1f  %6.2f\n", sky, sky2, (F/R));
    108106  }   

  • trunk/Ohana/src/opihi/cmd.basic/test/sprintf.sh

    r10311 r20936  
    3535 $PASS = 1
    3636
    37  if ($endmem - $startmem > 10)
     37 if (($endmem - $startmem)/10000 > 1.0)
    3838   $PASS = 0
    3939   echo "growth: {$endmem-$startmem}"

  • 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);

  • trunk/Ohana/src/opihi/dvo/Makefile

    r19579 r20936  
    2929$(SRC)/dvomisc.$(ARCH).o                \
    3030$(SRC)/region_list.$(ARCH).o            \
    31 $(SRC)/dvomisc.$(ARCH).o                \
    3231$(SRC)/dbBooleanCond.$(ARCH).o          \
    3332$(SRC)/dbCheckStack.$(ARCH).o           \
    … …  
    3534$(SRC)/dbExtractAverages.$(ARCH).o      \
    3635$(SRC)/dbExtractMeasures.$(ARCH).o      \
     36$(SRC)/dbExtractImages.$(ARCH).o        \
    3737$(SRC)/dbFields.$(ARCH).o               \
    3838$(SRC)/dbRPN.$(ARCH).o                  \
    … …  
    113113
    114114# deprecated functions: verify & delete
    115 #$(SRC)/catalog.$(ARCH).o               \
    116115#$(SRC)/abszero.$(ARCH).o \
    117116#$(SRC)/cals.$(ARCH).o \

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

    r20819 r20936  
    66  int Nsecfilt, mode, VERBOSE;
    77  char **cstack, name[1024];
    8   float *values;
    98  void *Signal;
    109
    1110  Catalog catalog;
     11
     12  Vector **vec;
     13  dbStack *stack;
     14  dbField *fields;
     15  dbValue *values;
    1216  SkyList *skylist;
    1317  SkyRegionSelection *selection;
    14   PhotCode *code;
    15   Vector **vec;
    16   dbField *fields;
    17   dbStack *stack;
    1818
    1919  /* defaults */
     20  vec = NULL;
     21  stack = NULL;
     22  fields = NULL;
     23  values = NULL;
    2024  skylist = NULL;
    2125  selection = NULL;
    22   code = NULL;
     26
    2327  mode = MAG_AVE;
    24   fields = NULL;
    25   stack = NULL;
    2628
    2729  if ((N = get_argument (argc, argv, "-h"))) goto help;
    … …  
    4749  // parse the fields to be extracted and returned
    4850  fields = dbCmdlineFields (argc, argv, DVO_TABLE_AVERAGE, &last, &Nfields);
    49   if (fields == NULL) return (FALSE);
     51  if (fields == NULL) goto escape;
     52  if (Nfields == 0) {
     53    FreeSkyRegionSelection (selection);
     54    dbFreeFields (fields, Nfields);
     55    dvo_catalog_free (&catalog);
     56    goto help;
     57  }
    5058
    5159  // examine line for 'where' or 'match to'.  'match to' is forbidden
    … …  
    6674  Nreturn = Nfields;
    6775  if (!dbCheckStack (stack, Nstack, DVO_TABLE_AVERAGE, &fields, &Nfields)) goto escape;
    68   // XXX handle errors
    6976
    7077  /* load region corresponding to selection above */
    … …  
    7279
    7380  /* create output storage vectors */
    74   ALLOCATE (values, float, Nfields);
     81  ALLOCATE (values, dbValue, Nfields);
    7582  ALLOCATE (vec, Vector *, Nreturn);
    7683  for (i = 0; i < Nreturn; i++) {
    … …  
    8188    }
    8289    if ((vec[i] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) goto escape;
     90    ResetVector (vec[i], fields[i].type, NPTS);
    8391  }
    8492
    … …  
    109117
    110118      m = catalog.average[j].measureOffset;
    111       dbExtractAveragesInit (); // reset counters for saved fields
     119
     120      // reset counters for saved fields, extract fields
     121      dbExtractAveragesInit ();
    112122      for (n = 0; n < Nfields; n++) {
    113123        values[n] = dbExtractAverages (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
    114124      }
     125
    115126      // test the conditional statement
    116127      if (!dbBooleanCond (stack, Nstack, values)) continue;
    117128      for (n = 0; n < Nreturn; n++) {
    118         vec[n][0].elements[Npts] = values[n];
     129        if (vec[n][0].type == OPIHI_FLT) {
     130          vec[n][0].elements.Flt[Npts] = values[n].Flt;
     131        } else {
     132          vec[n][0].elements.Int[Npts] = values[n].Int;
     133        }
    119134      }
    120135      Npts++;
    … …  
    122137        NPTS += 2000;
    123138        for (n = 0; n < Nreturn; n++) {
    124           REALLOCATE (vec[n][0].elements, float, NPTS);
     139          if (vec[n][0].type == OPIHI_FLT) {
     140            REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
     141          } else {
     142            REALLOCATE (vec[n][0].elements.Int, opihi_int, NPTS);
     143          }
    125144        }
    126145      }
    … …  
    132151  for (n = 0; n < Nreturn; n++) {
    133152    vec[n][0].Nelements = Npts;
    134     REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
    135   }
    136 
     153    if (vec[n][0].type == OPIHI_FLT) {
     154      REALLOCATE (vec[n][0].elements.Flt, opihi_flt, MAX(1,Npts));
     155    } else {
     156      REALLOCATE (vec[n][0].elements.Int, opihi_int, MAX(1,Npts));
     157    }
     158  }
     159
     160  if (vec) free (vec);
     161  if (values) free (values);
    137162  dbFreeFields (fields, Nfields);
    138163  dbFreeStack (stack, Nstack);
    139   free (stack);
     164  if (stack) free (stack);
    140165  SkyListFree (skylist);
    141166  FreeSkyRegionSelection (selection);
    … …  
    143168
    144169 escape:
     170  if (vec) free (vec);
     171  if (values) free (values);
    145172  dbFreeFields (fields, Nfields);
    146173  dbFreeStack (stack, Nstack);
    147   free (stack);
     174  if (stack) free (stack);
    148175  SkyListFree (skylist);
    149176  FreeSkyRegionSelection (selection);

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

    r15509 r20936  
    3838  if (!TestPhotSelections (&code[0], &mode[0], MEAS_ZERO)) goto escape;
    3939
     40  gprint (GP_ERR, "warning: this function may be deprecated in the future -- use avextract for better control\n");
     41
    4042  /* returned vectors are dmag, mag, color, time, airmass, ra, dec, x, y, exptime */
    41   N = 0;
    42   Nstar = 0;
    43   NSTAR = 100;
    4443  ALLOCATE (vec, Vector *, NVEC);
    4544  if ((vec[Nd ] = SelectVector ("cal:dmag",     ANYVECTOR, TRUE)) == NULL) goto escape;
    … …  
    6059  if ((vec[Nd1] = SelectVector ("cal:dm1",      ANYVECTOR, TRUE)) == NULL) goto escape;
    6160  if ((vec[Nd2] = SelectVector ("cal:dm2",      ANYVECTOR, TRUE)) == NULL) goto escape;
     61
     62  N = 0;
     63  Nstar = 0;
     64  NSTAR = 100;
    6265  for (k = 0; k < NVEC; k++) {
    63     REALLOCATE (vec[k][0].elements, float, NSTAR);
    64     vec[k][0].Nelements = 0;
     66    ResetVector (vec[k], OPIHI_FLT, NSTAR);
    6567  }
    6668
    … …  
    110112        NSTAR += N1 + 100;
    111113        for (k = 0; k < NVEC; k++) {
    112           REALLOCATE (vec[k][0].elements, float, NSTAR);
     114          REALLOCATE (vec[k][0].elements.Flt, opihi_flt, NSTAR);
    113115        }
    114116      }
    … …  
    125127
    126128      for (j = 0; j < N1; j++, N++) {
    127         vec[Nd ][0].elements[N] = M1[j] - M2;
    128         vec[Nm1][0].elements[N] = M1[j];
    129         vec[Nm2][0].elements[N] = M2;
    130         vec[Nd2][0].elements[N] = dM2;
    131         vec[Nc ][0].elements[N] = color;
    132         vec[Ns ][0].elements[N] = Nstar;
    133         vec[NR ][0].elements[N] = catalog.average[i].R;
    134         vec[ND ][0].elements[N] = catalog.average[i].D;
     129        vec[Nd ][0].elements.Flt[N] = M1[j] - M2;
     130        vec[Nm1][0].elements.Flt[N] = M1[j];
     131        vec[Nm2][0].elements.Flt[N] = M2;
     132        vec[Nd2][0].elements.Flt[N] = dM2;
     133        vec[Nc ][0].elements.Flt[N] = color;
     134        vec[Ns ][0].elements.Flt[N] = Nstar;
     135        vec[NR ][0].elements.Flt[N] = catalog.average[i].R;
     136        vec[ND ][0].elements.Flt[N] = catalog.average[i].D;
    135137      }
    136138      Nstar ++;
    … …  
    178180  Ns = vec[0].Nelements;
    179181  for (i = 0; i < N; i++) {
    180     vec[0].elements[Ns+i] = value[i];
     182    vec[0].elements.Flt[Ns+i] = value[i];
    181183  }
    182184  vec[0].Nelements = Ns + N;

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

    r20535 r20936  
    5151
    5252  /* init vectors to save data */
    53   Npts = 0;
    54   NPTS = 1;
    5553  if ((xvec = SelectVector ("xv", ANYVECTOR, TRUE)) == NULL) goto escape;
    5654  if ((yvec = SelectVector ("yv", ANYVECTOR, TRUE)) == NULL) goto escape;
     55
     56  gprint (GP_ERR, "warning: this function may be deprecated in the future -- use avextract for better control\n");
     57
     58  Npts = 0;
     59  NPTS = 100;
     60  ResetVector (xvec, OPIHI_FLT, NPTS);
     61  ResetVector (yvec, OPIHI_FLT, NPTS);
    5762
    5863  // grab data from all selected sky regions
    … …  
    97102      for (i1 = 0; i1 < N1; i1++) {
    98103        for (i2 = 0; i2 < N2; i2++) {
    99           xvec[0].elements[Npts] = M1[i1];
    100           yvec[0].elements[Npts] = M2[i2];
     104          xvec[0].elements.Flt[Npts] = M1[i1];
     105          yvec[0].elements.Flt[Npts] = M2[i2];
    101106          Npts++;
    102107          if (Npts >= NPTS) {
    103108            NPTS += 2000;
    104             REALLOCATE (xvec[0].elements, float, NPTS);
    105             REALLOCATE (yvec[0].elements, float, NPTS);
     109            REALLOCATE (xvec[0].elements.Flt, opihi_flt, NPTS);
     110            REALLOCATE (yvec[0].elements.Flt, opihi_flt, NPTS);
    106111          }
    107112        }

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

    r20535 r20936  
    4949
    5050  /* init vectors to save data */
    51   Npts = 0;
    52   NPTS = 1;
    5351  if ((xvec = SelectVector ("xv", ANYVECTOR, TRUE)) == NULL) goto escape;
    5452  if ((yvec = SelectVector ("yv", ANYVECTOR, TRUE)) == NULL) goto escape;
     53
     54  gprint (GP_ERR, "warning: this function may be deprecated in the future -- use avextract for better control\n");
     55
     56  Npts = 0;
     57  NPTS = 100;
     58  ResetVector (xvec, OPIHI_FLT, NPTS);
     59  ResetVector (yvec, OPIHI_FLT, NPTS);
    5560
    5661  // grab data from all selected sky regions
    … …  
    95100      for (i1 = 0; i1 < N1; i1++) {
    96101        for (i3 = 0; i3 < N3; i3++) {
    97           xvec[0].elements[Npts] = M1[i1];
    98           yvec[0].elements[Npts] = M3[i3];
     102          xvec[0].elements.Flt[Npts] = M1[i1];
     103          yvec[0].elements.Flt[Npts] = M3[i3];
    99104          Npts++;
    100105          if (Npts >= NPTS) {
    101106            NPTS += 2000;
    102             REALLOCATE (xvec[0].elements, float, NPTS);
    103             REALLOCATE (yvec[0].elements, float, NPTS);
     107            REALLOCATE (xvec[0].elements.Flt, opihi_flt, NPTS);
     108            REALLOCATE (yvec[0].elements.Flt, opihi_flt, NPTS);
    104109          }
    105110        }

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

    r15487 r20936  
    8989  fclose (f);
    9090
    91   REALLOCATE (vec[0].elements, float, Nstars);
    92   vec[0].Nelements = Nstars;
    93   bzero (vec[0].elements, Nstars*sizeof(float));
     91  ResetVector (vec, OPIHI_FLT, Nstars);
     92  bzero (vec[0].elements.Flt, Nstars*sizeof(opihi_flt));
    9493
    9594  value = 0;
    … …  
    135134        break;
    136135    }
    137     vec[0].elements[i] = value;
     136    vec[0].elements.Flt[i] = value;
    138137  }     
    139138  free (stars);

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

    r12332 r20936  
    1010  Nmatch = 0;
    1111  NMATCH = D_NMATCH;
    12   REALLOCATE (rvec[0].elements, float, NMATCH);
    13   REALLOCATE (dvec[0].elements, float, NMATCH);
    14   REALLOCATE (mvec[0].elements, float, NMATCH);
    15   REALLOCATE (drvec[0].elements, float, NMATCH);
    16   REALLOCATE (ddvec[0].elements, float, NMATCH);
    17   REALLOCATE (dmvec[0].elements, float, NMATCH);
     12  ResetVector ( rvec, OPIHI_FLT, NMATCH);
     13  ResetVector ( dvec, OPIHI_FLT, NMATCH);
     14  ResetVector ( mvec, OPIHI_FLT, NMATCH);
     15  ResetVector (drvec, OPIHI_FLT, NMATCH);
     16  ResetVector (ddvec, OPIHI_FLT, NMATCH);
     17  ResetVector (dmvec, OPIHI_FLT, NMATCH);
    1818
    1919  for (i = j = 0; (i < catlog1[0].Naverage) && (j < catlog2[0].Naverage);) {
    … …  
    3636        dR = hypot (dX, dY);
    3737        if (dR < radius) {
    38           rvec[0].elements[Nmatch] = catlog1[0].average[i].R;
    39           dvec[0].elements[Nmatch] = catlog1[0].average[i].D;
    40           // mvec[0].elements[Nmatch] = catlog1[0].average[i].M;
    41           drvec[0].elements[Nmatch] = dX;
    42           ddvec[0].elements[Nmatch] = dY;
    43           // dmvec[0].elements[Nmatch] = catlog1[0].average[i].M - catlog2[0].average[j].M;
     38          rvec[0].elements.Flt[Nmatch] = catlog1[0].average[i].R;
     39          dvec[0].elements.Flt[Nmatch] = catlog1[0].average[i].D;
     40          // mvec[0].elements.Flt[Nmatch] = catlog1[0].average[i].M;
     41          drvec[0].elements.Flt[Nmatch] = dX;
     42          ddvec[0].elements.Flt[Nmatch] = dY;
     43          // dmvec[0].elements.Flt[Nmatch] = catlog1[0].average[i].M - catlog2[0].average[j].M;
    4444          Nmatch ++;
    4545          if (Nmatch == NMATCH - 1) {
    4646            NMATCH += D_NMATCH;
    47             REALLOCATE ( rvec[0].elements, float, NMATCH);
    48             REALLOCATE ( dvec[0].elements, float, NMATCH);
    49             REALLOCATE ( mvec[0].elements, float, NMATCH);
    50             REALLOCATE (drvec[0].elements, float, NMATCH);
    51             REALLOCATE (ddvec[0].elements, float, NMATCH);
    52             REALLOCATE (dmvec[0].elements, float, NMATCH);
     47            REALLOCATE ( rvec[0].elements.Flt, opihi_flt, NMATCH);
     48            REALLOCATE ( dvec[0].elements.Flt, opihi_flt, NMATCH);
     49            REALLOCATE ( mvec[0].elements.Flt, opihi_flt, NMATCH);
     50            REALLOCATE (drvec[0].elements.Flt, opihi_flt, NMATCH);
     51            REALLOCATE (ddvec[0].elements.Flt, opihi_flt, NMATCH);
     52            REALLOCATE (dmvec[0].elements.Flt, opihi_flt, NMATCH);
    5353          }
    5454        }
    … …  
    5959  }
    6060
    61   REALLOCATE ( rvec[0].elements, float, Nmatch);
    62   REALLOCATE ( dvec[0].elements, float, Nmatch);
    63   REALLOCATE ( mvec[0].elements, float, Nmatch);
    64   REALLOCATE (drvec[0].elements, float, Nmatch);
    65   REALLOCATE (ddvec[0].elements, float, Nmatch);
    66   REALLOCATE (dmvec[0].elements, float, Nmatch);
    67  
    68   rvec[0].Nelements = Nmatch;
    69   dvec[0].Nelements = Nmatch;
    70   mvec[0].Nelements = Nmatch;
    71   drvec[0].Nelements = Nmatch;
    72   ddvec[0].Nelements = Nmatch;
    73   dmvec[0].Nelements = Nmatch;
    74 
     61  ResetVector ( rvec, OPIHI_FLT, Nmatch);
     62  ResetVector ( dvec, OPIHI_FLT, Nmatch);
     63  ResetVector ( mvec, OPIHI_FLT, Nmatch);
     64  ResetVector (drvec, OPIHI_FLT, Nmatch);
     65  ResetVector (ddvec, OPIHI_FLT, Nmatch);
     66  ResetVector (dmvec, OPIHI_FLT, Nmatch);
    7567}
    7668

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

    r15717 r20936  
    33// evaluate the expression in inStack as a boolean; necessary db field values are
    44// supplied by fields, in order 0 - Nfields (validate before calling)
    5 int dbBooleanCond (dbStack *inStack, int NinStack, float *fields) {
     5// XXX fields needs to be typed (dbValue), stack math needs to deal with the type cases
     6int dbBooleanCond (dbStack *inStack, int NinStack, dbValue *fields) {
    67 
    78  float value;
    … …  
    2122
    2223    /***** binary operators *****/
    23     if ((stack[i][0].type >= 3) && (stack[i][0].type <= 8)) {
     24    if ((stack[i][0].type >= DB_STACK_LOGIC) && (stack[i][0].type <= DB_STACK_POWER)) {
    2425
    2526      // pre-test that op and entries match
    … …  
    4142
    4243    /***** unary operators **/
    43     if (stack[i][0].type == 9) {
     44    if (stack[i][0].type == DB_STACK_UNARY) {
    4445
    4546      // pre-test that op and entries match
    … …  
    6162
    6263  // the result here is a single stack entry with a value:
    63   if (stack[0][0].type == 'F') {
     64  if (stack[0][0].type & DB_STACK_FIELD) {
    6465    N = stack[0][0].field;
    65     value = fields[N];
     66    value = (stack[0][0].type & DB_STACK_INT) ? fields[N].Int : fields[N].Flt;
    6667  } else {
    67     value = stack[0][0].Float;
     68    value = (stack[0][0].type & DB_STACK_INT) ? stack[0][0].IntValue : stack[0][0].FltValue;
    6869  }
    6970   

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

    r20818 r20936  
    11# include "dvoshell.h"
     2
     3// XXX we are using a fairly bogus set of char values to distinguish a few cases:
     4// 's', 'S' : value is a scalar (upper == float; lower == int)
     5// 'f', 'F' : value is a field (upper == float; lower == int)
     6// 't', 'T' : value is a temp scalar (upper == float; lower == int)
     7// these would be better done using bit values to test for field? temp? float?
    28
    39int dbCheckStack (dbStack *stack, int Nstack, int table, dbField **inFields, int *inNfields) {
    410
    511  int i, j, status, NFIELDS, Nfields;
    6   char *c;
     12  char *c1, *c2;
    713  dbField *fields;
    814
    … …  
    1420
    1521  for (i = 0; i < Nstack; i++) {
    16     if (stack[i].type == 'X') {
     22    if (stack[i].type == DB_STACK_VALUE) {
    1723
    18       /** if this is a number, put it on the list of scalers and move on **/
    19       stack[i].Float = strtod (stack[i].name, &c);
    20       if (c == stack[i].name + strlen (stack[i].name)) {
    21         stack[i].type  = 'S';
     24      /** if this is a number, put it on the list of scalars and move on.  assume value is
     25       * an int unless proven otherwise **/
     26      stack[i].FltValue = strtod (stack[i].name, &c1);
     27      stack[i].IntValue = strtol (stack[i].name, &c2, 0);
     28      if (c2 == stack[i].name + strlen (stack[i].name)) {
     29        stack[i].type  |= DB_STACK_INT;
     30        continue;
     31      }
     32      if (c1 == stack[i].name + strlen (stack[i].name)) {
     33        // this is a float value
    2234        continue;
    2335      }
    … …  
    4456          code = GetPhotcodebyName (tmpstring);
    4557          if (code) {
    46               stack[i].Float = code->code;
    47               stack[i].type  = 'S';
     58              stack[i].IntValue = code->code;
     59              stack[i].type = DB_STACK_INT;
    4860              continue;
    4961          }
    … …  
    6072      if (j < Nfields) {
    6173        stack[i].field = j;
    62         stack[i].type  = 'F';
     74        stack[i].type |= DB_STACK_FIELD;
     75        if (fields[j].type == OPIHI_INT) {
     76          stack[i].type |= DB_STACK_INT;
     77        }
    6378        stack[i].name  = NULL;
    64         stack[i].Float = 0.0;
     79        stack[i].FltValue = 0.0;
     80        stack[i].IntValue =   0;
    6581        continue;
    6682      }
    6783
    6884      // this must be a field : is it a valid name?
     85      status = FALSE;
    6986      if (table == DVO_TABLE_MEASURE) {
    7087        status = ParseMeasureField (&fields[Nfields], stack[i].name);
    … …  
    7390        status = ParseAverageField (&fields[Nfields], stack[i].name);
    7491      }
     92      if (table == DVO_TABLE_IMAGE) {
     93        status = ParseImageField (&fields[Nfields], stack[i].name);
     94      }
    7595      if (!status) {
    76         gprint (GP_ERR, "unknown database field %s\n", stack[i].name);
    7796        goto failure;
    7897      }
    7998      stack[i].field = Nfields;
    80       stack[i].type  = 'F';
     99      stack[i].type |= DB_STACK_FIELD;
     100      if (fields[Nfields].type == OPIHI_INT) {
     101        stack[i].type |= DB_STACK_INT;
     102      }
    81103      stack[i].name  = NULL;
    82       stack[i].Float = 0.0;
     104      stack[i].FltValue = 0.0; // 'F'
     105      stack[i].IntValue =   0; // 'f'
    83106
    84107      Nfields ++;

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

    r19579 r20936  
    7777        status = ParseAverageField (&fields[Nfields], field);
    7878      }
     79      if (table == DVO_TABLE_IMAGE) {
     80        status = ParseImageField (&fields[Nfields], field);
     81      }
    7982      if (!status) {
    80         gprint (GP_ERR, "unknown database field %s\n", field);
    8183        free (field);
    8284        dbFreeFields (fields, Nfields);
    … …  
    143145  REALLOCATE (*stack, dbStack, N + 20);
    144146
     147  Rname = Dname = NULL;
     148  if (table == DVO_TABLE_MEASURE) {
     149    Rname = strcreate ("RA:AVE");
     150    Dname = strcreate ("DEC:AVE");
     151  }
    145152  if (table == DVO_TABLE_AVERAGE) {
    146153    Rname = strcreate ("RA");
    147154    Dname = strcreate ("DEC");
    148   } else {
    149     Rname = strcreate ("RA:AVE");
    150     Dname = strcreate ("DEC:AVE");
    151   }
     155  }
     156  if (table == DVO_TABLE_IMAGE) {
     157    Rname = strcreate ("RA");
     158    Dname = strcreate ("DEC");
     159  }
     160  if (Rname == NULL) return (FALSE);
    152161
    153162  // add: ((ra > rmin) && (ra < rmax) && (dec > dmin) && (dec < dmax))
    … …  
    155164
    156165  stack[0][N +  0].name = strcreate (Rname);
    157   stack[0][N +  0].type = 'X';
     166  stack[0][N +  0].type = DB_STACK_VALUE;
    158167  stack[0][N +  1].name = strfloat (Rmin);
    159   stack[0][N +  1].type = 'X';
     168  stack[0][N +  1].type = DB_STACK_VALUE;
    160169  stack[0][N +  2].name = strcreate (">");
    161   stack[0][N +  2].type = 4;
    162   // stack[0][N +  3].name = strcreate ("A");
    163   // stack[0][N +  3].type = 3;
     170  stack[0][N +  2].type = DB_STACK_COMPARE;
    164171
    165172  stack[0][N +  3].name = strcreate (Rname);
    166   stack[0][N +  3].type = 'X';
     173  stack[0][N +  3].type = DB_STACK_VALUE;
    167174  stack[0][N +  4].name = strfloat (Rmax);
    168   stack[0][N +  4].type = 'X';
     175  stack[0][N +  4].type = DB_STACK_VALUE;
    169176  stack[0][N +  5].name = strcreate ("<");
    170   stack[0][N +  5].type = 4;
     177  stack[0][N +  5].type = DB_STACK_COMPARE;
    171178  stack[0][N +  6].name = strcreate ("A");
    172   stack[0][N +  6].type = 3;
     179  stack[0][N +  6].type = DB_STACK_LOGIC;
    173180
    174181  stack[0][N +  7].name = strcreate (Dname);
    175   stack[0][N +  7].type = 'X';
     182  stack[0][N +  7].type = DB_STACK_VALUE;
    176183  stack[0][N +  8].name = strfloat (Dmin);
    177   stack[0][N +  8].type = 'X';
     184  stack[0][N +  8].type = DB_STACK_VALUE;
    178185  stack[0][N +  9].name = strcreate (">");
    179   stack[0][N +  9].type = 4;
     186  stack[0][N +  9].type = DB_STACK_COMPARE;
    180187  stack[0][N + 10].name = strcreate ("A");
    181   stack[0][N + 10].type = 3;
     188  stack[0][N + 10].type = DB_STACK_LOGIC;
    182189
    183190  stack[0][N + 11].name = strcreate (Dname);
    184   stack[0][N + 11].type = 'X';
     191  stack[0][N + 11].type = DB_STACK_VALUE;
    185192  stack[0][N + 12].name = strfloat (Dmax);
    186   stack[0][N + 12].type = 'X';
     193  stack[0][N + 12].type = DB_STACK_VALUE;
    187194  stack[0][N + 13].name = strcreate ("<");
    188   stack[0][N + 13].type = 4;
     195  stack[0][N + 13].type = DB_STACK_COMPARE;
    189196  stack[0][N + 14].name = strcreate ("A");
    190   stack[0][N + 14].type = 3;
     197  stack[0][N + 14].type = DB_STACK_LOGIC;
    191198
    192199  if (N == 0) {
    … …  
    194201  } else {
    195202    stack[0][N + 15].name = strcreate ("A");
    196     stack[0][N + 15].type = 3;
     203    stack[0][N + 15].type = DB_STACK_LOGIC;
    197204    N += 16;
    198205  }   

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

    r17201 r20936  
    4040
    4141/* return average.field based on the selection */
    42 double dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
     42dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
    4343
    4444  int i, Nsec;
    45   double value;
     45  dbValue value;
    4646
    47   value = NAN;
     47  value.Flt = NAN;
     48  value.Int =   0;
    4849
    4950  /* assign vector values */
    5051  switch (field->ID) {
    5152    case AVE_RA:
    52       value = average[0].R;
     53      value.Flt = average[0].R;
    5354      break;
    5455    case AVE_DEC:
    55       value = average[0].D;
     56      value.Flt = average[0].D;
    5657      break;
    5758    case AVE_GLON:
    … …  
    6061        haveGalactic = TRUE;
    6162      }
    62       value = GLON;
     63      value.Flt = GLON;
    6364      break;
    6465    case AVE_GLAT:
    … …  
    6768        haveGalactic = TRUE;
    6869      }
    69       value = GLAT;
     70      value.Flt = GLAT;
    7071      break;
    7172    case AVE_ELON:
    … …  
    7475        haveEcliptic = TRUE;
    7576      }
    76       value = ELON;
     77      value.Flt = ELON;
    7778      break;
    7879    case AVE_ELAT:
    … …  
    8182        haveEcliptic = TRUE;
    8283      }
    83       value = ELAT;
     84      value.Flt = ELAT;
    8485      break;
    8586    case AVE_RA_ERR:
    86       value = average[0].dR;
     87      value.Flt = average[0].dR;
    8788      break;
    8889    case AVE_DEC_ERR:
    89       value = average[0].dD;
     90      value.Flt = average[0].dD;
    9091      break;
    9192
    9293    case AVE_U_RA:
    93       value = average[0].uR;
     94      value.Flt = average[0].uR;
    9495      break;
    9596    case AVE_U_DEC:
    96       value = average[0].uD;
     97      value.Flt = average[0].uD;
    9798      break;
    9899    case AVE_U_RA_ERR:
    99       value = average[0].duR;
     100      value.Flt = average[0].duR;
    100101      break;
    101102    case AVE_U_DEC_ERR:
    102       value = average[0].duD;
     103      value.Flt = average[0].duD;
    103104      break;
    104105
    105106    case AVE_PAR:
    106       value = average[0].P;
     107      value.Flt = average[0].P;
    107108      break;
    108109    case AVE_PAR_ERR:
    109       value = average[0].dP;
     110      value.Flt = average[0].dP;
    110111      break;
    111112
    112113    case AVE_NMEAS:
    113       value = average[0].Nmeasure;
     114      value.Int = average[0].Nmeasure;
    114115      break;
    115116    case AVE_NMISS:
    116       value = average[0].Nmissing;
     117      value.Int = average[0].Nmissing;
    117118      break;
    118119    case AVE_Xp:
    119       value = 0.01*average[0].Xp;
     120      value.Flt = 0.01*average[0].Xp;
    120121      break;
    121122    case AVE_FLAG:
    122       value = average[0].code;
     123      value.Int = average[0].code;
     124      break;
     125    case AVE_OBJID:
     126      value.Int = average[0].objID;
     127      break;
     128    case AVE_CATID:
     129      value.Int = average[0].catID;
    123130      break;
    124131
    … …  
    126133      switch (field->magMode) {
    127134        case MAG_AVE:
    128           value = PhotAve  (field->photcode, average, secfilt);
     135          value.Flt = PhotAve  (field->photcode, average, secfilt);
    129136          break;
    130137        case MAG_REF:
    131           value = PhotRef  (field->photcode, average, secfilt, measure);
     138          value.Flt = PhotRef  (field->photcode, average, secfilt, measure);
    132139          break;
    133140        case MAG_INST:
    … …  
    137144        case MAG_CAL:
    138145          // XXX need to code this correctly: this returns just the first matching value
    139           value = NAN;
     146          value.Flt = NAN;
    140147          for (i = 0; i < average[0].Nmeasure; i++) {
    141148            if (field->photcode->code != measure[i].photcode) continue;
    142             value = measure[i].M;
     149            value.Flt = measure[i].M;
    143150            break;
    144151          }
    … …  
    146153        case MAG_CHISQ:
    147154          // GetPhotcodeEquivCodebyCode (field->photcode)
    148           value = PhotXm (field->photcode, average, secfilt);
     155          value.Flt = PhotXm (field->photcode, average, secfilt);
    149156          break;
    150157        case MAG_ERR:
    151158          // GetPhotcodeEquivCodebyCode (field->photcode)
    152           if (field->photcode->type == PHOT_REF) {
     159          if ((field->photcode->type == PHOT_REF) || (field->photcode->type == PHOT_DEP)) {
    153160            for (i = 0; i < average[0].Nmeasure; i++) {
    154161              if (field->photcode->code != measure[i].photcode) continue;
    155               value = measure[i].dM;
     162              value.Flt = measure[i].dM;
    156163              break;
    157164            }
    158165          } else {
    159             value = PhotdM (field->photcode, average, secfilt);
     166            value.Flt = PhotdM (field->photcode, average, secfilt);
    160167          }
    161168          break;
    … …  
    165172          Nsec = GetPhotcodeNsec (field->photcode->code);
    166173          if (Nsec == -1) break;
    167           value = secfilt[Nsec].Ncode;
     174          value.Int = secfilt[Nsec].Ncode;
    168175          break;
    169176        case MAG_NPHOT:
    170177          Nsec = GetPhotcodeNsec (field->photcode->code);
    171178          if (Nsec == -1) break;
    172           value = secfilt[Nsec].Nused;
     179          value.Int = secfilt[Nsec].Nused;
    173180          break;
    174181
    … …  
    176183      break;
    177184    case AVE_dMAG:
    178       value = PhotdM (field->photcode, average, secfilt);
     185      value.Flt = PhotdM (field->photcode, average, secfilt);
    179186      break;
    180187    case AVE_Xm:
    181       value = PhotXm (field->photcode, average, secfilt);
     188      value.Flt = PhotXm (field->photcode, average, secfilt);
    182189      break;
    183190    case AVE_TYPE:
    … …  
    185192    case AVE_TYPEFRAC:
    186193      break;
    187       /*
    188     case AVE_NCODE:
    189       value = 0;
    190       for (i = 0; i < average[0].Nm; i++) {
    191         if (field->photcode->code != GetPhotcodeEquivCodebyCode (measure[i].photcode)) continue;
    192         value ++;
    193       }
    194       break;
    195     case AVE_NPHOT:
    196       value = 0;
    197       for (i = 0; i < average[0].Nm; i++) {
    198         if (field->photcode->code != GetPhotcodeEquivCodebyCode (measure[i].photcode)) continue;
    199         if (measure[i].flags & (ID_MEAS_POOR_PHOTOM | ID_MEAS_SKIP_PHOTOM)) continue;
    200         value ++;
    201       }
    202       break;
    203     case AVE_NCRIT:
    204       break;
    205       */
    206194  }
    207195  return (value);

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

    r18221 r20936  
    3131static double ELAT_MEAS = 0.0;
    3232
    33 void dbExtractMeasuresInit () {
     33int dbExtractMeasuresInit () {
    3434  TimeRefPM = ohana_date_to_sec ("2000/01/01");
    3535  GetTimeFormat (&TimeReference, &TimeFormat);
     36  return (TRUE);
    3637}
    3738
    … …  
    7071
    7172/* return measure.field based on the selection */
    72 double dbExtractMeasures (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
     73dbValue dbExtractMeasures (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
    7374
    7475  int Nsec;
    75   double value;
     76  dbValue value;
    7677  double ra, dec, x, y, dT;
    7778
    … …  
    7980  PhotCode *equiv;
    8081
    81   value = NAN;
     82  value.Flt = NAN;
     83  value.Int =   0;
    8284
    8385  switch (field->ID) {
    … …  
    9698      switch (field->magMode) {
    9799        case MAG_INST:
    98           value = PhotInst (measure); 
     100          value.Flt = PhotInst (measure); 
    99101          break;
    100102        case MAG_CAT:
    101           value = PhotCat  (measure);
     103          value.Flt = PhotCat  (measure);
    102104          break;
    103105        case MAG_SYS:
    104           value = PhotSys  (measure, average, secfilt);
     106          value.Flt = PhotSys  (measure, average, secfilt);
    105107          break;
    106108        case MAG_REL:
    107           value = PhotRel  (measure, average, secfilt);
     109          value.Flt = PhotRel  (measure, average, secfilt);
    108110          break;
    109111        case MAG_CAL:
    110           value = PhotCal  (measure, average, secfilt, measure, equiv);
     112          value.Flt = PhotCal  (measure, average, secfilt, measure, equiv);
    111113          break;
    112114        case MAG_AVE:
    113           value = PhotAve  (equiv, average, secfilt);
     115          value.Flt = PhotAve  (equiv, average, secfilt);
    114116          break;
    115117        case MAG_REF:
    116           value = PhotRef  (equiv, average, secfilt, measure);
     118          value.Flt = PhotRef  (equiv, average, secfilt, measure);
    117119          break;
    118120        case MAG_ERR:
    119121          if (field->photcode->type == PHOT_SEC) {
    120             value = PhotdM  (equiv, average, secfilt);
     122            value.Flt = PhotdM  (equiv, average, secfilt);
    121123          } else {
    122             value = measure[0].dM;
     124            value.Flt = measure[0].dM;
    123125          }
    124126          break;
    125127        case MAG_CHISQ:
    126           value = PhotXm  (equiv, average, secfilt);
     128          value.Flt = PhotXm  (equiv, average, secfilt);
    127129          break;
    128130        case MAG_NCODE:
    129131          if (equiv == NULL) {
    130             value = NAN;
     132            value.Int = 0;
    131133            break;
    132134          }
    133135          Nsec = GetPhotcodeNsec (equiv->code);
    134136          if (Nsec == -1) break;
    135           value = secfilt[Nsec].Ncode;
     137          value.Int = secfilt[Nsec].Ncode;
    136138          break;
    137139        case MAG_NPHOT:
    138140          if (equiv == NULL) {
    139             value = NAN;
     141            value.Int = NAN;
    140142            break;
    141143          }
    142144          Nsec = GetPhotcodeNsec (equiv->code);
    143145          if (Nsec == -1) break;
    144           value = secfilt[Nsec].Nused;
     146          value.Int = secfilt[Nsec].Nused;
    145147          break;
    146148      }
    147149      break;
    148150    case MEAS_RA: /* OK */
    149       value = average[0].R - measure[0].dR / 3600.0;
     151      value.Flt = average[0].R - measure[0].dR / 3600.0;
    150152      break;
    151153    case MEAS_DEC: /* OK */
    152       value = average[0].D - measure[0].dD / 3600.0;
     154      value.Flt = average[0].D - measure[0].dD / 3600.0;
    153155      break;
    154156    case MEAS_RA_AVE: /* OK */
    155       value = average[0].R;
     157      value.Flt = average[0].R;
    156158      break;
    157159    case MEAS_DEC_AVE: /* OK */
    158       value = average[0].D;
     160      value.Flt = average[0].D;
    159161      break;
    160162
    … …  
    164166        haveGalacticMeas = TRUE;
    165167      }
    166       value = GLON_MEAS;
     168      value.Flt = GLON_MEAS;
    167169      break;
    168170    case MEAS_GLAT:
    … …  
    171173        haveGalacticMeas = TRUE;
    172174      }
    173       value = GLAT_MEAS;
     175      value.Flt = GLAT_MEAS;
    174176      break;
    175177    case MEAS_ELON:
    … …  
    178180        haveEclipticMeas = TRUE;
    179181      }
    180       value = ELON_MEAS;
     182      value.Flt = ELON_MEAS;
    181183      break;
    182184    case MEAS_ELAT:
    … …  
    185187        haveEclipticMeas = TRUE;
    186188      }
    187       value = ELAT_MEAS;
     189      value.Flt = ELAT_MEAS;
    188190      break;
    189191
    … …  
    193195        haveGalacticAve = TRUE;
    194196      }
    195       value = GLON_AVE;
     197      value.Flt = GLON_AVE;
    196198      break;
    197199    case MEAS_GLAT_AVE:
    … …  
    200202        haveGalacticAve = TRUE;
    201203      }
    202       value = GLAT_AVE;
     204      value.Flt = GLAT_AVE;
    203205      break;
    204206    case MEAS_ELON_AVE:
    … …  
    207209        haveEclipticAve = TRUE;
    208210      }
    209       value = ELON_AVE;
     211      value.Flt = ELON_AVE;
    210212      break;
    211213    case MEAS_ELAT_AVE:
    … …  
    214216        haveEclipticAve = TRUE;
    215217      }
    216       value = ELAT_AVE;
     218      value.Flt = ELAT_AVE;
    217219      break;
    218220
    219221    case MEAS_RA_AVE_ERR: /* OK */
    220       value = average[0].dR;
     222      value.Flt = average[0].dR;
    221223      break;
    222224    case MEAS_DEC_AVE_ERR: /* OK */
    223       value = average[0].dD;
     225      value.Flt = average[0].dD;
    224226      break;
    225227    case MEAS_U_RA: /* OK */
    226       value = average[0].uR;
     228      value.Flt = average[0].uR;
    227229      break;
    228230    case MEAS_U_DEC: /* OK */
    229       value = average[0].uD;
     231      value.Flt = average[0].uD;
    230232      break;
    231233    case MEAS_U_RA_ERR: /* OK */
    232       value = average[0].duR;
     234      value.Flt = average[0].duR;
    233235      break;
    234236    case MEAS_U_DEC_ERR: /* OK */
    235       value = average[0].duD;
     237      value.Flt = average[0].duD;
    236238      break;
    237239    case MEAS_PAR: /* OK */
    238       value = average[0].R;
     240      value.Flt = average[0].R;
    239241      break;
    240242    case MEAS_PAR_ERR: /* OK */
    241       value = average[0].D;
     243      value.Flt = average[0].D;
    242244      break;
    243245    case MEAS_XP: /* OK */
    244       value = average[0].Xp;
     246      value.Flt = average[0].Xp;
    245247      break;
    246248    case MEAS_NMEAS: /* OK */
    247       value = average[0].Nmeasure;
     249      value.Int = average[0].Nmeasure;
    248250      break;
    249251    case MEAS_NMISS: /* OK */
    250       value = average[0].Nmissing;
     252      value.Int = average[0].Nmissing;
    251253      break;
    252254    case MEAS_OBJFLAGS: /* OK */
    253       value = average[0].code;
     255      value.Int = average[0].code;
    254256      break;
    255257    // note that these represent the ra displacement relative to the average, not
    256258    // the error.
    257259    case MEAS_RA_OFFSET: /* OK */
    258       value = measure[0].dR;
     260      value.Flt = measure[0].dR;
    259261      break;
    260262    case MEAS_DEC_OFFSET: /* OK */
    261       value = measure[0].dD;
     263      value.Flt = measure[0].dD;
    262264      break;
    263265    case MEAS_RA_FIT_OFFSET: /* OK */
    264266      dT = (measure[0].t - TimeRefPM) / (86400*365.25);
    265       value = average[0].uR * dT + measure[0].dR;
     267      value.Flt = average[0].uR * dT + measure[0].dR;
    266268      break;
    267269    case MEAS_DEC_FIT_OFFSET: /* OK */
    268270      dT = (measure[0].t - TimeRefPM) / (86400*365.25);
    269       value = average[0].uD * dT + measure[0].dD;
     271      value.Flt = average[0].uD * dT + measure[0].dD;
    270272      break;
    271273    case MEAS_RA_OFFSET_ERR: /* OK */
    272       value = NAN;
     274      value.Flt = NAN;
    273275      break;
    274276    case MEAS_DEC_OFFSET_ERR: /* OK */
    275       value = NAN;
     277      value.Flt = NAN;
    276278      break;
    277279    case MEAS_AIRMASS: /* OK */
    278       value = measure[0].airmass;
     280      value.Flt = measure[0].airmass;
    279281      break;
    280282    case MEAS_AZ: /* OK */
    281       value = measure[0].az;
     283      value.Flt = measure[0].az;
    282284      break;
    283285    case MEAS_EXPTIME: /* OK */
    284       value = pow (10.0, measure[0].dt * 0.4);
     286      value.Flt = pow (10.0, measure[0].dt * 0.4);
    285287      break;
    286288    case MEAS_PHOTCODE: /* OK */
    287       value = measure[0].photcode;
     289      value.Int = measure[0].photcode;
    288290      break;
    289291    case MEAS_TIME: /* OK */
    290       value = TimeValue (measure[0].t, TimeReference, TimeFormat);
     292      value.Flt = TimeValue (measure[0].t, TimeReference, TimeFormat);
    291293      break;
    292294    case MEAS_FWHM: /* OK */
    293       value = 0.01*(measure[0].FWx + measure[0].FWy) / 2.0;
     295      value.Flt = 0.01*(measure[0].FWx + measure[0].FWy) / 2.0;
    294296      break;
    295297    case MEAS_FWHM_MAJ: /* OK */
    296       value = 0.01*measure[0].FWx;
     298      value.Flt = 0.01*measure[0].FWx;
    297299      break;
    298300    case MEAS_FWHM_MIN: /* OK */
    299       value = 0.01*measure[0].FWy;
     301      value.Flt = 0.01*measure[0].FWy;
    300302      break;
    301303    case MEAS_THETA: /* OK */
    302       value = measure[0].theta;
     304      value.Flt = measure[0].theta;
    303305      break;
    304306    case MEAS_DOPHOT: /* OK */
    305       value = measure[0].dophot;
     307      value.Flt = measure[0].dophot;
    306308      break;
    307309    case MEAS_DB_FLAGS: /* ? */
    308       value = measure[0].dbFlags;
     310      value.Int = measure[0].dbFlags;
    309311      break;
    310312    case MEAS_PHOT_FLAGS: /* ? */
    311       value = measure[0].photFlags;
     313      value.Int = measure[0].photFlags;
    312314      break;
    313315    case MEAS_XCCD: /* OK */
    314316/* I need to perform this conversion for ELIXIR and LONEOS formats on load */     
    315317# if 1
    316       value = measure[0].Xccd;
     318      value.Flt = measure[0].Xccd;
    317319# else
    318320      {
    … …  
    323325        if (image == NULL) break;
    324326        RD_to_XY (&x, &y, ra, dec, &image[0].coords);
    325         value = x;
     327        value.Flt = x;
    326328      }
    327329# endif
    … …  
    330332/* I need to perform this conversion for ELIXIR and LONEOS formats on load */     
    331333# if 1
    332       value = measure[0].Yccd;
     334      value.Flt = measure[0].Yccd;
    333335# else
    334336      {
    … …  
    339341        if (image == NULL) break;
    340342        RD_to_XY (&x, &y, ra, dec, &image[0].coords);
    341         value = y;
     343        value.Flt = y;
    342344      }
    343345# endif
     346      break;
     347    case MEAS_XCCD_ERR: /* OK */
     348      value.Flt = measure[0].dXccd;
     349      break;
     350    case MEAS_YCCD_ERR: /* OK */
     351      value.Flt = measure[0].dYccd;
    344352      break;
    345353    case MEAS_XMOSAIC: /* OK */
    … …  
    349357      if (mosaic == NULL) break;
    350358      RD_to_XY (&x, &y, ra, dec, mosaic);
    351       value = x;
     359      value.Flt = x;
    352360      break;
    353361    case MEAS_YMOSAIC: /* OK */
    … …  
    357365      if (mosaic == NULL) break;
    358366      RD_to_XY (&x, &y, ra, dec, mosaic);
    359       value = y;
     367      value.Flt = y;
    360368      break;
    361369
    362370    case MEAS_SKY: /* OK */
    363       value = measure[0].Sky;
     371      value.Flt = measure[0].Sky;
    364372      break;
    365373    case MEAS_dSKY: /* OK */
    366       value = measure[0].dSky;
     374      value.Flt = measure[0].dSky;
    367375      break;
    368376    case MEAS_DET_ID: /* OK */
    369       value = measure[0].detID;
     377      value.Int = measure[0].detID;
    370378      break;
    371379    case MEAS_OBJ_ID: /* OK */
    372       value = measure[0].averef;
     380      // XXX this should probably return average[0].objID
     381      value.Int = average[0].objID;
    373382      break;
    374383    case MEAS_IMAGE_ID: /* OK */
    375       value = measure[0].imageID;
     384      value.Int = measure[0].imageID;
    376385      break;
    377386    case MEAS_PSF_QF: /* OK */
    378       value = measure[0].qPSF;
     387      value.Flt = measure[0].qPSF;
    379388      break;
    380389    case MEAS_PSF_CHISQ: /* OK */
    381       value = measure[0].psfChisq;
     390      value.Flt = measure[0].psfChisq;
    382391      break;
    383392    case MEAS_CR_NSIGMA: /* OK */
    384       value = measure[0].crNsigma;
     393      value.Flt = measure[0].crNsigma;
    385394      break;
    386395    case MEAS_EXT_NSIGMA: /* OK */
    387       value = measure[0].extNsigma;
     396      value.Flt = measure[0].extNsigma;
    388397      break;
    389398    case MEAS_STARGAL: /* OK */
    390       value = measure[0].stargal;
    391       break;
     399      value.Flt = measure[0].stargal;
     400      break;
     401
     402      // add the star/galaxy sep --
    392403  }
    393404  return (value);

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

    r17199 r20936  
    2323  field->table = 0;
    2424  field->ID = 0;
     25  field->type = OPIHI_FLT;
    2526  field->magMode = 0;
    2627  field->photcode = NULL;
    … …  
    8990}
    9091
    91 # define ESCAPE(F,M) { \
     92# define ESCAPE(F,M,T) { \
    9293  field->ID = (F); \
    9394  field->magMode = (M); \
     95  field->type = (T); \
    9496  field->photcode = NULL; \
    9597  return (TRUE); }
    … …  
    105107  if (!strcasecmp (fieldName, "GLON"))       {
    106108    dbExtractMeasuresInitTransform (COORD_GALACTIC);
    107     ESCAPE (MEAS_GLON, MAG_NONE);
     109    ESCAPE (MEAS_GLON, MAG_NONE, OPIHI_FLT);
    108110  }
    109111  if (!strcasecmp (fieldName, "GLAT")) {
    110112    dbExtractMeasuresInitTransform (COORD_GALACTIC);
    111     ESCAPE (MEAS_GLAT, MAG_NONE);
     113    ESCAPE (MEAS_GLAT, MAG_NONE, OPIHI_FLT);
    112114  }
    113115  if (!strcasecmp (fieldName, "GLON:AVE")) {
    114116    dbExtractMeasuresInitTransform (COORD_GALACTIC);
    115     ESCAPE (MEAS_GLON_AVE, MAG_NONE);
     117    ESCAPE (MEAS_GLON_AVE, MAG_NONE, OPIHI_FLT);
    116118  }
    117119  if (!strcasecmp (fieldName, "GLAT:AVE")) {
    118120    dbExtractMeasuresInitTransform (COORD_GALACTIC);
    119     ESCAPE (MEAS_GLAT_AVE, MAG_NONE);
     121    ESCAPE (MEAS_GLAT_AVE, MAG_NONE, OPIHI_FLT);
    120122  }
    121123
    122124  if (!strcasecmp (fieldName, "ELON"))       {
    123125    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    124     ESCAPE (MEAS_ELON, MAG_NONE);
     126    ESCAPE (MEAS_ELON, MAG_NONE, OPIHI_FLT);
    125127  }
    126128  if (!strcasecmp (fieldName, "ELAT")) {
    127129    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    128     ESCAPE (MEAS_ELAT, MAG_NONE);
     130    ESCAPE (MEAS_ELAT, MAG_NONE, OPIHI_FLT);
    129131  }
    130132  if (!strcasecmp (fieldName, "ELON:AVE")) {
    131133    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    132     ESCAPE (MEAS_ELON_AVE, MAG_NONE);
     134    ESCAPE (MEAS_ELON_AVE, MAG_NONE, OPIHI_FLT);
    133135  }
    134136  if (!strcasecmp (fieldName, "ELAT:AVE")) {
    135137    dbExtractMeasuresInitTransform (COORD_ECLIPTIC);
    136     ESCAPE (MEAS_ELAT_AVE, MAG_NONE);
    137   }
    138 
    139   if (!strcasecmp (fieldName, "RA"))         ESCAPE (MEAS_RA,           MAG_NONE);
    140   if (!strcasecmp (fieldName, "DEC"))        ESCAPE (MEAS_DEC,          MAG_NONE);
    141   if (!strcasecmp (fieldName, "RA:AVE"))     ESCAPE (MEAS_RA_AVE,       MAG_NONE);
    142   if (!strcasecmp (fieldName, "DEC:AVE"))    ESCAPE (MEAS_DEC_AVE,      MAG_NONE);
    143   if (!strcasecmp (fieldName, "RA:ERR"))     ESCAPE (MEAS_RA_AVE_ERR,   MAG_NONE);
    144   if (!strcasecmp (fieldName, "DEC:ERR"))    ESCAPE (MEAS_DEC_AVE_ERR,  MAG_NONE);
    145 
    146   if (!strcasecmp (fieldName, "uRA"))        ESCAPE (MEAS_U_RA,         MAG_NONE);
    147   if (!strcasecmp (fieldName, "uDEC"))       ESCAPE (MEAS_U_DEC,        MAG_NONE);
    148   if (!strcasecmp (fieldName, "duRA"))       ESCAPE (MEAS_U_RA_ERR,     MAG_NONE);
    149   if (!strcasecmp (fieldName, "duDEC"))      ESCAPE (MEAS_U_DEC_ERR,    MAG_NONE);
    150   if (!strcasecmp (fieldName, "PAR"))        ESCAPE (MEAS_PAR,          MAG_NONE);
    151   if (!strcasecmp (fieldName, "dPAR"))       ESCAPE (MEAS_PAR_ERR,      MAG_NONE);
    152   if (!strcasecmp (fieldName, "dR"))         ESCAPE (MEAS_RA_OFFSET,    MAG_NONE);
    153   if (!strcasecmp (fieldName, "dD"))         ESCAPE (MEAS_DEC_OFFSET,   MAG_NONE);
    154   if (!strcasecmp (fieldName, "dR:FIT"))     ESCAPE (MEAS_RA_FIT_OFFSET,  MAG_NONE);
    155   if (!strcasecmp (fieldName, "dD:FIT"))     ESCAPE (MEAS_DEC_FIT_OFFSET, MAG_NONE);
    156   if (!strcasecmp (fieldName, "dR:ERR"))     ESCAPE (MEAS_RA_OFFSET_ERR,  MAG_NONE);
    157   if (!strcasecmp (fieldName, "dD:ERR"))     ESCAPE (MEAS_DEC_OFFSET_ERR, MAG_NONE);
    158   if (!strcasecmp (fieldName, "xp"))         ESCAPE (MEAS_XP,           MAG_NONE);
    159   if (!strcasecmp (fieldName, "nmeas"))      ESCAPE (MEAS_NMEAS,        MAG_NONE);
    160   if (!strcasecmp (fieldName, "nmiss"))      ESCAPE (MEAS_NMISS,        MAG_NONE);
    161   if (!strcasecmp (fieldName, "objflags"))   ESCAPE (MEAS_OBJFLAGS,     MAG_NONE);
    162   if (!strcasecmp (fieldName, "AIRMASS"))    ESCAPE (MEAS_AIRMASS,      MAG_NONE);
    163   if (!strcasecmp (fieldName, "ALT"))        ESCAPE (MEAS_ALT,          MAG_NONE);
    164   if (!strcasecmp (fieldName, "AZ"))         ESCAPE (MEAS_AZ,           MAG_NONE);
    165   if (!strcasecmp (fieldName, "EXPTIME"))    ESCAPE (MEAS_EXPTIME,      MAG_NONE);
    166   if (!strcasecmp (fieldName, "PHOTCODE"))   ESCAPE (MEAS_PHOTCODE,     MAG_NONE);
    167   if (!strcasecmp (fieldName, "TIME"))       ESCAPE (MEAS_TIME,         MAG_NONE);
    168   if (!strcasecmp (fieldName, "FWHM"))       ESCAPE (MEAS_FWHM,         MAG_NONE);
    169   if (!strcasecmp (fieldName, "FWHM_MAJ"))   ESCAPE (MEAS_FWHM_MAJ,     MAG_NONE);
    170   if (!strcasecmp (fieldName, "FWHM_MIN"))   ESCAPE (MEAS_FWHM_MIN,     MAG_NONE);
    171   if (!strcasecmp (fieldName, "THETA"))      ESCAPE (MEAS_THETA,        MAG_NONE);
    172   if (!strcasecmp (fieldName, "DOPHOT"))     ESCAPE (MEAS_DOPHOT,       MAG_NONE);
    173   if (!strcasecmp (fieldName, "DB_FLAGS"))   ESCAPE (MEAS_DB_FLAGS,     MAG_NONE);
    174   if (!strcasecmp (fieldName, "PHOT_FLAGS")) ESCAPE (MEAS_PHOT_FLAGS,   MAG_NONE);
    175   if (!strcasecmp (fieldName, "XCCD"))       ESCAPE (MEAS_XCCD,         MAG_NONE);
    176   if (!strcasecmp (fieldName, "YCCD"))       ESCAPE (MEAS_YCCD,         MAG_NONE);
    177   if (!strcasecmp (fieldName, "XMOSAIC"))    ESCAPE (MEAS_XMOSAIC,      MAG_NONE);
    178   if (!strcasecmp (fieldName, "YMOSAIC"))    ESCAPE (MEAS_YMOSAIC,      MAG_NONE);
    179   if (!strcasecmp (fieldName, "XCHIP"))      ESCAPE (MEAS_XCCD,         MAG_NONE);
    180   if (!strcasecmp (fieldName, "YCHIP"))      ESCAPE (MEAS_YCCD,         MAG_NONE);
    181   if (!strcasecmp (fieldName, "XFPA"))       ESCAPE (MEAS_XMOSAIC,      MAG_NONE);
    182   if (!strcasecmp (fieldName, "YFPA"))       ESCAPE (MEAS_YMOSAIC,      MAG_NONE);
    183   if (!strcasecmp (fieldName, "DETID"))      ESCAPE (MEAS_DET_ID,       MAG_NONE);
    184   if (!strcasecmp (fieldName, "OBJID"))      ESCAPE (MEAS_OBJ_ID,       MAG_NONE);
    185   if (!strcasecmp (fieldName, "IMAGEID"))    ESCAPE (MEAS_IMAGE_ID,     MAG_NONE);
    186   if (!strcasecmp (fieldName, "PSF_QF"))     ESCAPE (MEAS_PSF_QF,       MAG_NONE);
    187   if (!strcasecmp (fieldName, "PSF_CHISQ"))  ESCAPE (MEAS_PSF_CHISQ,    MAG_NONE);
    188   if (!strcasecmp (fieldName, "CR_NSIGMA"))  ESCAPE (MEAS_CR_NSIGMA,    MAG_NONE);
    189   if (!strcasecmp (fieldName, "EXT_NSIGMA")) ESCAPE (MEAS_EXT_NSIGMA,   MAG_NONE);
    190   if (!strcasecmp (fieldName, "SKY"))        ESCAPE (MEAS_SKY,          MAG_NONE);
    191   if (!strcasecmp (fieldName, "SKY_ERR"))    ESCAPE (MEAS_dSKY,         MAG_NONE);
    192   if (!strcasecmp (fieldName, "STARGAL"))    ESCAPE (MEAS_STARGAL,      MAG_NONE);
     138    ESCAPE (MEAS_ELAT_AVE, MAG_NONE, OPIHI_FLT);
     139  }
     140
     141  if (!strcasecmp (fieldName, "RA"))         ESCAPE (MEAS_RA,             MAG_NONE, OPIHI_FLT);
     142  if (!strcasecmp (fieldName, "DEC"))        ESCAPE (MEAS_DEC,            MAG_NONE, OPIHI_FLT);
     143  if (!strcasecmp (fieldName, "RA:AVE"))     ESCAPE (MEAS_RA_AVE,         MAG_NONE, OPIHI_FLT);
     144  if (!strcasecmp (fieldName, "DEC:AVE"))    ESCAPE (MEAS_DEC_AVE,        MAG_NONE, OPIHI_FLT);
     145  if (!strcasecmp (fieldName, "RA:ERR"))     ESCAPE (MEAS_RA_AVE_ERR,     MAG_NONE, OPIHI_FLT);
     146  if (!strcasecmp (fieldName, "DEC:ERR"))    ESCAPE (MEAS_DEC_AVE_ERR,    MAG_NONE, OPIHI_FLT);
     147  if (!strcasecmp (fieldName, "uRA"))        ESCAPE (MEAS_U_RA,           MAG_NONE, OPIHI_FLT);
     148  if (!strcasecmp (fieldName, "uDEC"))       ESCAPE (MEAS_U_DEC,          MAG_NONE, OPIHI_FLT);
     149  if (!strcasecmp (fieldName, "duRA"))       ESCAPE (MEAS_U_RA_ERR,       MAG_NONE, OPIHI_FLT);
     150  if (!strcasecmp (fieldName, "duDEC"))      ESCAPE (MEAS_U_DEC_ERR,      MAG_NONE, OPIHI_FLT);
     151  if (!strcasecmp (fieldName, "PAR"))        ESCAPE (MEAS_PAR,            MAG_NONE, OPIHI_FLT);
     152  if (!strcasecmp (fieldName, "dPAR"))       ESCAPE (MEAS_PAR_ERR,        MAG_NONE, OPIHI_FLT);
     153  if (!strcasecmp (fieldName, "dR"))         ESCAPE (MEAS_RA_OFFSET,      MAG_NONE, OPIHI_FLT);
     154  if (!strcasecmp (fieldName, "dD"))         ESCAPE (MEAS_DEC_OFFSET,     MAG_NONE, OPIHI_FLT);
     155  if (!strcasecmp (fieldName, "dR:FIT"))     ESCAPE (MEAS_RA_FIT_OFFSET,  MAG_NONE, OPIHI_FLT);
     156  if (!strcasecmp (fieldName, "dD:FIT"))     ESCAPE (MEAS_DEC_FIT_OFFSET, MAG_NONE, OPIHI_FLT);
     157  if (!strcasecmp (fieldName, "dR:ERR"))     ESCAPE (MEAS_RA_OFFSET_ERR,  MAG_NONE, OPIHI_FLT);
     158  if (!strcasecmp (fieldName, "dD:ERR"))     ESCAPE (MEAS_DEC_OFFSET_ERR, MAG_NONE, OPIHI_FLT);
     159  if (!strcasecmp (fieldName, "xp"))         ESCAPE (MEAS_XP,             MAG_NONE, OPIHI_FLT);
     160  if (!strcasecmp (fieldName, "nmeas"))      ESCAPE (MEAS_NMEAS,          MAG_NONE, OPIHI_INT);
     161  if (!strcasecmp (fieldName, "nmiss"))      ESCAPE (MEAS_NMISS,          MAG_NONE, OPIHI_INT);
     162  if (!strcasecmp (fieldName, "objflags"))   ESCAPE (MEAS_OBJFLAGS,       MAG_NONE, OPIHI_INT);
     163  if (!strcasecmp (fieldName, "AIRMASS"))    ESCAPE (MEAS_AIRMASS,        MAG_NONE, OPIHI_FLT);
     164  if (!strcasecmp (fieldName, "ALT"))        ESCAPE (MEAS_ALT,            MAG_NONE, OPIHI_FLT);
     165  if (!strcasecmp (fieldName, "AZ"))         ESCAPE (MEAS_AZ,             MAG_NONE, OPIHI_FLT);
     166  if (!strcasecmp (fieldName, "EXPTIME"))    ESCAPE (MEAS_EXPTIME,        MAG_NONE, OPIHI_FLT);
     167  if (!strcasecmp (fieldName, "PHOTCODE"))   ESCAPE (MEAS_PHOTCODE,       MAG_NONE, OPIHI_INT);
     168  if (!strcasecmp (fieldName, "TIME"))       ESCAPE (MEAS_TIME,           MAG_NONE, OPIHI_FLT);
     169  if (!strcasecmp (fieldName, "FWHM"))       ESCAPE (MEAS_FWHM,           MAG_NONE, OPIHI_FLT);
     170  if (!strcasecmp (fieldName, "FWHM_MAJ"))   ESCAPE (MEAS_FWHM_MAJ,       MAG_NONE, OPIHI_FLT);
     171  if (!strcasecmp (fieldName, "FWHM_MIN"))   ESCAPE (MEAS_FWHM_MIN,       MAG_NONE, OPIHI_FLT);
     172  if (!strcasecmp (fieldName, "THETA"))      ESCAPE (MEAS_THETA,          MAG_NONE, OPIHI_FLT);
     173  if (!strcasecmp (fieldName, "DOPHOT"))     ESCAPE (MEAS_DOPHOT,         MAG_NONE, OPIHI_FLT);
     174  if (!strcasecmp (fieldName, "DB_FLAGS"))   ESCAPE (MEAS_DB_FLAGS,       MAG_NONE, OPIHI_INT);
     175  if (!strcasecmp (fieldName, "PHOT_FLAGS")) ESCAPE (MEAS_PHOT_FLAGS,     MAG_NONE, OPIHI_INT);
     176  if (!strcasecmp (fieldName, "XCCD"))       ESCAPE (MEAS_XCCD,           MAG_NONE, OPIHI_FLT);
     177  if (!strcasecmp (fieldName, "YCCD"))       ESCAPE (MEAS_YCCD,           MAG_NONE, OPIHI_FLT);
     178  if (!strcasecmp (fieldName, "XCCD:ERR"))   ESCAPE (MEAS_XCCD_ERR,       MAG_NONE, OPIHI_FLT);
     179  if (!strcasecmp (fieldName, "YCCD:ERR"))   ESCAPE (MEAS_YCCD_ERR,       MAG_NONE, OPIHI_FLT);
     180  if (!strcasecmp (fieldName, "XMOSAIC"))    ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
     181  if (!strcasecmp (fieldName, "YMOSAIC"))    ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
     182  if (!strcasecmp (fieldName, "XCHIP"))      ESCAPE (MEAS_XCCD,           MAG_NONE, OPIHI_FLT);
     183  if (!strcasecmp (fieldName, "YCHIP"))      ESCAPE (MEAS_YCCD,           MAG_NONE, OPIHI_FLT);
     184  if (!strcasecmp (fieldName, "XFPA"))       ESCAPE (MEAS_XMOSAIC,        MAG_NONE, OPIHI_FLT);
     185  if (!strcasecmp (fieldName, "YFPA"))       ESCAPE (MEAS_YMOSAIC,        MAG_NONE, OPIHI_FLT);
     186  if (!strcasecmp (fieldName, "DETID"))      ESCAPE (MEAS_DET_ID,         MAG_NONE, OPIHI_INT);
     187  if (!strcasecmp (fieldName, "OBJID"))      ESCAPE (MEAS_OBJ_ID,         MAG_NONE, OPIHI_INT);
     188  if (!strcasecmp (fieldName, "IMAGEID"))    ESCAPE (MEAS_IMAGE_ID,       MAG_NONE, OPIHI_INT);
     189  if (!strcasecmp (fieldName, "PSF_QF"))     ESCAPE (MEAS_PSF_QF,         MAG_NONE, OPIHI_FLT);
     190  if (!strcasecmp (fieldName, "PSF_CHISQ"))  ESCAPE (MEAS_PSF_CHISQ,      MAG_NONE, OPIHI_FLT);
     191  if (!strcasecmp (fieldName, "CR_NSIGMA"))  ESCAPE (MEAS_CR_NSIGMA,      MAG_NONE, OPIHI_FLT);
     192  if (!strcasecmp (fieldName, "EXT_NSIGMA")) ESCAPE (MEAS_EXT_NSIGMA,     MAG_NONE, OPIHI_FLT);
     193  if (!strcasecmp (fieldName, "SKY"))        ESCAPE (MEAS_SKY,            MAG_NONE, OPIHI_FLT);
     194  if (!strcasecmp (fieldName, "SKY_ERR"))    ESCAPE (MEAS_dSKY,           MAG_NONE, OPIHI_FLT);
     195  if (!strcasecmp (fieldName, "STARGAL"))    ESCAPE (MEAS_STARGAL,        MAG_NONE, OPIHI_FLT);
    193196
    194197  // for words that don't parse, try a photcode
    … …  
    196199  // check for code:mode in photcode name
    197200  code = ParsePhotcodeField (fieldName, &mode, MAG_REL);
    198   if (code == NULL) return (FALSE);
     201  if (code == NULL) {
     202    gprint (GP_ERR, "unknown field '%s' for measurement table in DVO database\n", fieldName);
     203    return (FALSE);
     204  }
    199205
    200206  field->ID = MEAS_MAG;
    201207  field->magMode = mode;
     208  field->type = OPIHI_FLT;
    202209  field->photcode = code;
    203210  return (TRUE);
    … …  
    216223  if (!strcasecmp (fieldName, "GLON"))  {
    217224    dbExtractAveragesInitTransform (COORD_GALACTIC);
    218     ESCAPE (AVE_GLON, MAG_NONE);
     225    ESCAPE (AVE_GLON, MAG_NONE, OPIHI_FLT);
    219226  }
    220227  if (!strcasecmp (fieldName, "GLAT"))  {
    221228    dbExtractAveragesInitTransform (COORD_GALACTIC);
    222     ESCAPE (AVE_GLAT, MAG_NONE);
     229    ESCAPE (AVE_GLAT, MAG_NONE, OPIHI_FLT);
    223230  }
    224231
    … …  
    227234  if (!strcasecmp (fieldName, "ELON"))  {
    228235    dbExtractAveragesInitTransform (COORD_ECLIPTIC);
    229     ESCAPE (AVE_ELON, MAG_NONE);
     236    ESCAPE (AVE_ELON, MAG_NONE, OPIHI_FLT);
    230237  }
    231238  if (!strcasecmp (fieldName, "ELAT"))  {
    232239    dbExtractAveragesInitTransform (COORD_ECLIPTIC);
    233     ESCAPE (AVE_ELAT, MAG_NONE);
    234   }
    235 
    236   if (!strcasecmp (fieldName, "RA"))    ESCAPE (AVE_RA,        MAG_NONE);
    237   if (!strcasecmp (fieldName, "DEC"))   ESCAPE (AVE_DEC,       MAG_NONE);
    238   if (!strcasecmp (fieldName, "dRA"))   ESCAPE (AVE_RA_ERR,    MAG_NONE);
    239   if (!strcasecmp (fieldName, "dDEC"))  ESCAPE (AVE_DEC_ERR,   MAG_NONE);
    240   if (!strcasecmp (fieldName, "uRA"))   ESCAPE (AVE_U_RA,      MAG_NONE);
    241   if (!strcasecmp (fieldName, "uDEC"))  ESCAPE (AVE_U_DEC,     MAG_NONE);
    242   if (!strcasecmp (fieldName, "duRA"))  ESCAPE (AVE_U_RA_ERR,  MAG_NONE);
    243   if (!strcasecmp (fieldName, "duDEC")) ESCAPE (AVE_U_DEC_ERR, MAG_NONE);
    244   if (!strcasecmp (fieldName, "PAR"))   ESCAPE (AVE_PAR,       MAG_NONE);
    245   if (!strcasecmp (fieldName, "dPAR"))  ESCAPE (AVE_PAR_ERR,   MAG_NONE);
    246   if (!strcasecmp (fieldName, "Xp"))    ESCAPE (AVE_Xp,        MAG_NONE);
    247   if (!strcasecmp (fieldName, "NMEAS")) ESCAPE (AVE_NMEAS,     MAG_NONE);
    248   if (!strcasecmp (fieldName, "NMISS")) ESCAPE (AVE_NMISS,     MAG_NONE);
    249   if (!strcasecmp (fieldName, "FLAG"))  ESCAPE (AVE_FLAG,      MAG_NONE);
    250   if (!strcasecmp (fieldName, "TYPE"))  ESCAPE (AVE_TYPE,      MAG_NONE);
    251   if (!strcasecmp (fieldName, "OBJID")) ESCAPE (AVE_OBJID,     MAG_NONE);
     240    ESCAPE (AVE_ELAT, MAG_NONE, OPIHI_FLT);
     241  }
     242
     243  if (!strcasecmp (fieldName, "RA"))    ESCAPE (AVE_RA,        MAG_NONE, OPIHI_FLT);
     244  if (!strcasecmp (fieldName, "DEC"))   ESCAPE (AVE_DEC,       MAG_NONE, OPIHI_FLT);
     245  if (!strcasecmp (fieldName, "GLON"))  ESCAPE (AVE_GLON,      MAG_NONE, OPIHI_FLT);
     246  if (!strcasecmp (fieldName, "GLAT"))  ESCAPE (AVE_GLAT,      MAG_NONE, OPIHI_FLT);
     247  if (!strcasecmp (fieldName, "ELON"))  ESCAPE (AVE_ELON,      MAG_NONE, OPIHI_FLT);
     248  if (!strcasecmp (fieldName, "ELAT"))  ESCAPE (AVE_ELAT,      MAG_NONE, OPIHI_FLT);
     249  if (!strcasecmp (fieldName, "dRA"))   ESCAPE (AVE_RA_ERR,    MAG_NONE, OPIHI_FLT);
     250  if (!strcasecmp (fieldName, "dDEC"))  ESCAPE (AVE_DEC_ERR,   MAG_NONE, OPIHI_FLT);
     251  if (!strcasecmp (fieldName, "uRA"))   ESCAPE (AVE_U_RA,      MAG_NONE, OPIHI_FLT);
     252  if (!strcasecmp (fieldName, "uDEC"))  ESCAPE (AVE_U_DEC,     MAG_NONE, OPIHI_FLT);
     253  if (!strcasecmp (fieldName, "duRA"))  ESCAPE (AVE_U_RA_ERR,  MAG_NONE, OPIHI_FLT);
     254  if (!strcasecmp (fieldName, "duDEC")) ESCAPE (AVE_U_DEC_ERR, MAG_NONE, OPIHI_FLT);
     255  if (!strcasecmp (fieldName, "PAR"))   ESCAPE (AVE_PAR,       MAG_NONE, OPIHI_FLT);
     256  if (!strcasecmp (fieldName, "dPAR"))  ESCAPE (AVE_PAR_ERR,   MAG_NONE, OPIHI_FLT);
     257  if (!strcasecmp (fieldName, "Xp"))    ESCAPE (AVE_Xp,        MAG_NONE, OPIHI_FLT);
     258  if (!strcasecmp (fieldName, "NMEAS")) ESCAPE (AVE_NMEAS,     MAG_NONE, OPIHI_INT);
     259  if (!strcasecmp (fieldName, "NMISS")) ESCAPE (AVE_NMISS,     MAG_NONE, OPIHI_INT);
     260  if (!strcasecmp (fieldName, "FLAG"))  ESCAPE (AVE_FLAG,      MAG_NONE, OPIHI_INT);
     261  if (!strcasecmp (fieldName, "TYPE"))  ESCAPE (AVE_TYPE,      MAG_NONE, OPIHI_INT);
     262  if (!strcasecmp (fieldName, "OBJID")) ESCAPE (AVE_OBJID,     MAG_NONE, OPIHI_INT);
     263  if (!strcasecmp (fieldName, "CATID")) ESCAPE (AVE_CATID,     MAG_NONE, OPIHI_INT);
    252264
    253265  // for words that don't parse, try a photcode
    … …  
    255267  // check for code:mode in photcode name
    256268  code = ParsePhotcodeField (fieldName, &mode, MAG_AVE);
    257   if (code == NULL) return (FALSE);
     269  if (code == NULL) {
     270    gprint (GP_ERR, "unknown field '%s' for average table in DVO database\n", fieldName);
     271    return (FALSE);
     272  }
     273
    258274  if (code[0].type == PHOT_MAG) {
    259275    gprint (GP_ERR, "'mag' is ambiguous for avextract\n");
    … …  
    264280  field->ID = AVE_MAG;
    265281  field->magMode = mode;
     282  field->type = OPIHI_FLT;
    266283  field->photcode = code;
    267284  return (TRUE);
    268285}
     286
     287int ParseImageField (dbField *field, char *fieldName) {
     288
     289  field->table = DVO_TABLE_IMAGE;
     290  field->name  = strcreate (fieldName);
     291
     292  // if either GLON or GLAT is requested, we set up a static tranformation
     293  // at prepare to calculate the values only once for each row
     294  if (!strcasecmp (fieldName, "GLON"))  {
     295    dbExtractImagesInitTransform (COORD_GALACTIC);
     296    ESCAPE (IMAGE_GLON, MAG_NONE, OPIHI_FLT);
     297  }
     298  if (!strcasecmp (fieldName, "GLAT"))  {
     299    dbExtractImagesInitTransform (COORD_GALACTIC);
     300    ESCAPE (IMAGE_GLAT, MAG_NONE, OPIHI_FLT);
     301  }
     302
     303  // if either ELON or ELAT is requested, we set up a static tranformation
     304  // at prepare to calculate the values only once for each row
     305  if (!strcasecmp (fieldName, "ELON"))  {
     306    dbExtractImagesInitTransform (COORD_ECLIPTIC);
     307    ESCAPE (IMAGE_ELON, MAG_NONE, OPIHI_FLT);
     308  }
     309  if (!strcasecmp (fieldName, "ELAT"))  {
     310    dbExtractImagesInitTransform (COORD_ECLIPTIC);
     311    ESCAPE (IMAGE_ELAT, MAG_NONE, OPIHI_FLT);
     312  }
     313
     314  if (!strcasecmp (fieldName, "RA"       )) ESCAPE (IMAGE_RA,        MAG_NONE, OPIHI_FLT);
     315  if (!strcasecmp (fieldName, "DEC"      )) ESCAPE (IMAGE_DEC,       MAG_NONE, OPIHI_FLT);
     316  if (!strcasecmp (fieldName, "GLON"     )) ESCAPE (IMAGE_GLON,      MAG_NONE, OPIHI_FLT);
     317  if (!strcasecmp (fieldName, "GLAT"     )) ESCAPE (IMAGE_GLAT,      MAG_NONE, OPIHI_FLT);
     318  if (!strcasecmp (fieldName, "ELON"     )) ESCAPE (IMAGE_ELON,      MAG_NONE, OPIHI_FLT);
     319  if (!strcasecmp (fieldName, "ELAT"     )) ESCAPE (IMAGE_ELAT,      MAG_NONE, OPIHI_FLT);
     320
     321  if (!strcasecmp (fieldName, "theta"    )) ESCAPE (IMAGE_THETA,     MAG_NONE, OPIHI_FLT);
     322  if (!strcasecmp (fieldName, "skew"     )) ESCAPE (IMAGE_SKEW,      MAG_NONE, OPIHI_FLT);
     323  if (!strcasecmp (fieldName, "scale"    )) ESCAPE (IMAGE_SCALE,     MAG_NONE, OPIHI_FLT);
     324  if (!strcasecmp (fieldName, "dscale"   )) ESCAPE (IMAGE_DSCALE,    MAG_NONE, OPIHI_FLT);
     325
     326  if (!strcasecmp (fieldName, "time"     )) ESCAPE (IMAGE_TIME,      MAG_NONE, OPIHI_FLT);
     327  if (!strcasecmp (fieldName, "nstar"    )) ESCAPE (IMAGE_NSTAR,     MAG_NONE, OPIHI_INT);
     328  if (!strcasecmp (fieldName, "airmass"  )) ESCAPE (IMAGE_AIRMASS,   MAG_NONE, OPIHI_FLT);
     329  if (!strcasecmp (fieldName, "NX"       )) ESCAPE (IMAGE_NX_PIX,    MAG_NONE, OPIHI_INT);
     330  if (!strcasecmp (fieldName, "NY"       )) ESCAPE (IMAGE_NY_PIX,    MAG_NONE, OPIHI_INT);
     331  if (!strcasecmp (fieldName, "apresid"  )) ESCAPE (IMAGE_APRESID,   MAG_NONE, OPIHI_FLT);
     332  if (!strcasecmp (fieldName, "dapresid" )) ESCAPE (IMAGE_DAPRESID,  MAG_NONE, OPIHI_FLT);
     333
     334  if (!strcasecmp (fieldName, "Mcal"     )) ESCAPE (IMAGE_MCAL,      MAG_NONE, OPIHI_FLT);
     335  if (!strcasecmp (fieldName, "dMcal"    )) ESCAPE (IMAGE_dMCAL,     MAG_NONE, OPIHI_FLT);
     336  if (!strcasecmp (fieldName, "Xm"       )) ESCAPE (IMAGE_XM,        MAG_NONE, OPIHI_FLT);
     337  if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE,  MAG_NONE, OPIHI_INT);
     338  if (!strcasecmp (fieldName, "exptime"  )) ESCAPE (IMAGE_EXPTIME,   MAG_NONE, OPIHI_FLT);
     339  if (!strcasecmp (fieldName, "sidtime"  )) ESCAPE (IMAGE_SIDTIME,   MAG_NONE, OPIHI_FLT);
     340
     341  if (!strcasecmp (fieldName, "latitude" )) ESCAPE (IMAGE_LATITUDE,  MAG_NONE, OPIHI_FLT);
     342
     343  if (!strcasecmp (fieldName, "detlimit" )) ESCAPE (IMAGE_DET_LIMIT, MAG_NONE, OPIHI_FLT);
     344  if (!strcasecmp (fieldName, "satlimit" )) ESCAPE (IMAGE_SAT_LIMIT, MAG_NONE, OPIHI_FLT);
     345  if (!strcasecmp (fieldName, "cerror"   )) ESCAPE (IMAGE_CERROR,    MAG_NONE, OPIHI_FLT);
     346
     347  if (!strcasecmp (fieldName, "FWHM"     )) ESCAPE (IMAGE_FWHM,      MAG_NONE, OPIHI_FLT);
     348  if (!strcasecmp (fieldName, "FWHM_MAJ" )) ESCAPE (IMAGE_FWHM_MAJ,  MAG_NONE, OPIHI_FLT);
     349  if (!strcasecmp (fieldName, "FWHM_MIN" )) ESCAPE (IMAGE_FWHM_MIN,  MAG_NONE, OPIHI_FLT);
     350  if (!strcasecmp (fieldName, "trate"    )) ESCAPE (IMAGE_TRATE,     MAG_NONE, OPIHI_FLT);
     351
     352  // XXX : these are mapped to ridiculous things: Myyyy + 0x8000 and Mxxxx
     353  if (!strcasecmp (fieldName, "ncal"     )) ESCAPE (IMAGE_NCAL,      MAG_NONE, OPIHI_INT);
     354  if (!strcasecmp (fieldName, "sky"      )) ESCAPE (IMAGE_SKY,       MAG_NONE, OPIHI_FLT);
     355
     356  if (!strcasecmp (fieldName, "flag"     )) ESCAPE (IMAGE_FLAG,      MAG_NONE, OPIHI_INT);
     357  if (!strcasecmp (fieldName, "ccdnum"   )) ESCAPE (IMAGE_CCDNUM,    MAG_NONE, OPIHI_INT);
     358
     359  if (!strcasecmp (fieldName, "imageID"  )) ESCAPE (IMAGE_IMAGE_ID,  MAG_NONE, OPIHI_INT);
     360  if (!strcasecmp (fieldName, "externID" )) ESCAPE (IMAGE_EXTERN_ID, MAG_NONE, OPIHI_INT);
     361  if (!strcasecmp (fieldName, "sourceID" )) ESCAPE (IMAGE_SOURCE_ID, MAG_NONE, OPIHI_INT);
     362
     363  if (!strcasecmp (fieldName, "X_LL_CHIP")) ESCAPE (IMAGE_X_LL_CHIP, MAG_NONE, OPIHI_FLT);
     364  if (!strcasecmp (fieldName, "X_LR_CHIP")) ESCAPE (IMAGE_X_LR_CHIP, MAG_NONE, OPIHI_FLT);
     365  if (!strcasecmp (fieldName, "X_UL_CHIP")) ESCAPE (IMAGE_X_UL_CHIP, MAG_NONE, OPIHI_FLT);
     366  if (!strcasecmp (fieldName, "X_UR_CHIP")) ESCAPE (IMAGE_X_UR_CHIP, MAG_NONE, OPIHI_FLT);
     367  if (!strcasecmp (fieldName, "Y_LL_CHIP")) ESCAPE (IMAGE_Y_LL_CHIP, MAG_NONE, OPIHI_FLT);
     368  if (!strcasecmp (fieldName, "Y_LR_CHIP")) ESCAPE (IMAGE_Y_LR_CHIP, MAG_NONE, OPIHI_FLT);
     369  if (!strcasecmp (fieldName, "Y_UL_CHIP")) ESCAPE (IMAGE_Y_UL_CHIP, MAG_NONE, OPIHI_FLT);
     370  if (!strcasecmp (fieldName, "Y_UR_CHIP")) ESCAPE (IMAGE_Y_UR_CHIP, MAG_NONE, OPIHI_FLT);
     371  if (!strcasecmp (fieldName, "X_LL_FP"  )) ESCAPE (IMAGE_X_LL_FP,   MAG_NONE, OPIHI_FLT);
     372  if (!strcasecmp (fieldName, "X_LR_FP"  )) ESCAPE (IMAGE_X_LR_FP,   MAG_NONE, OPIHI_FLT);
     373  if (!strcasecmp (fieldName, "X_UL_FP"  )) ESCAPE (IMAGE_X_UL_FP,   MAG_NONE, OPIHI_FLT);
     374  if (!strcasecmp (fieldName, "X_UR_FP"  )) ESCAPE (IMAGE_X_UR_FP,   MAG_NONE, OPIHI_FLT);
     375  if (!strcasecmp (fieldName, "Y_LL_FP"  )) ESCAPE (IMAGE_Y_LL_FP,   MAG_NONE, OPIHI_FLT);
     376  if (!strcasecmp (fieldName, "Y_LR_FP"  )) ESCAPE (IMAGE_Y_LR_FP,   MAG_NONE, OPIHI_FLT);
     377  if (!strcasecmp (fieldName, "Y_UL_FP"  )) ESCAPE (IMAGE_Y_UL_FP,   MAG_NONE, OPIHI_FLT);
     378  if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   MAG_NONE, OPIHI_FLT);
     379
     380  // for words that don't parse, try a photcode
     381  gprint (GP_ERR, "unknown field '%s' for image table in DVO database\n", fieldName);
     382  return (FALSE);
     383}

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

    r13479 r20936  
    2121   
    2222    /* decide on priority of object */
    23     type = 0;
     23    type = DB_STACK_NONE;
    2424    /* unary operations */
    25     if (!strcmp (argv[i], "abs"))    { type = 9; goto gotit; }
    26     if (!strcmp (argv[i], "int"))    { type = 9; goto gotit; }
    27     if (!strcmp (argv[i], "exp"))    { type = 9; goto gotit; }
    28     if (!strcmp (argv[i], "ten"))    { type = 9; goto gotit; }
    29     if (!strcmp (argv[i], "log"))    { type = 9; goto gotit; }
    30     if (!strcmp (argv[i], "ln"))     { type = 9; goto gotit; }
    31     if (!strcmp (argv[i], "sqrt"))   { type = 9; goto gotit; }
    32     if (!strcmp (argv[i], "erf"))    { type = 9; goto gotit; }
    33 
    34     if (!strcmp (argv[i], "sinh"))   { type = 9; goto gotit; }
    35     if (!strcmp (argv[i], "cosh"))   { type = 9; goto gotit; }
    36     if (!strcmp (argv[i], "asinh"))  { type = 9; goto gotit; }
    37     if (!strcmp (argv[i], "acosh"))  { type = 9; goto gotit; }
    38 
    39     if (!strcmp (argv[i], "sin"))    { type = 9; goto gotit; }
    40     if (!strcmp (argv[i], "cos"))    { type = 9; goto gotit; }
    41     if (!strcmp (argv[i], "tan"))    { type = 9; goto gotit; }
    42     if (!strcmp (argv[i], "dsin"))   { type = 9; goto gotit; }
    43     if (!strcmp (argv[i], "dcos"))   { type = 9; goto gotit; }
    44     if (!strcmp (argv[i], "dtan"))   { type = 9; goto gotit; }
    45     if (!strcmp (argv[i], "asin"))   { type = 9; goto gotit; }
    46     if (!strcmp (argv[i], "acos"))   { type = 9; goto gotit; }
    47     if (!strcmp (argv[i], "atan"))   { type = 9; goto gotit; }
    48     if (!strcmp (argv[i], "dasin"))  { type = 9; goto gotit; }
    49     if (!strcmp (argv[i], "dacos"))  { type = 9; goto gotit; }
    50     if (!strcmp (argv[i], "datan"))  { type = 9; goto gotit; }
    51 
    52     if (!strcmp (argv[i], "lgamma")) { type = 9; goto gotit; }
    53 
    54     if (!strcmp (argv[i], "rnd"))    { type = 9; goto gotit; }
    55     if (!strcmp (argv[i], "xramp"))  { type = 9; goto gotit; }
    56     if (!strcmp (argv[i], "yramp"))  { type = 9; goto gotit; }
    57     if (!strcmp (argv[i], "ramp"))   { type = 9; goto gotit; }
    58     if (!strcmp (argv[i], "zero"))   { type = 9; goto gotit; }
    59     if (!strcmp (argv[i], "--"))     { type = 9; goto gotit; }
    60     if (!strcmp (argv[i], "not"))    { type = 9; goto gotit; }
    61     if (!strcmp (argv[i], "isinf"))  { type = 9; goto gotit; }
    62     if (!strcmp (argv[i], "isnan"))  { type = 9; goto gotit; }
     25    if (!strcmp (argv[i], "abs"))    { type = DB_STACK_UNARY; goto gotit; }
     26    if (!strcmp (argv[i], "int"))    { type = DB_STACK_UNARY; goto gotit; }
     27    if (!strcmp (argv[i], "exp"))    { type = DB_STACK_UNARY; goto gotit; }
     28    if (!strcmp (argv[i], "ten"))    { type = DB_STACK_UNARY; goto gotit; }
     29    if (!strcmp (argv[i], "log"))    { type = DB_STACK_UNARY; goto gotit; }
     30    if (!strcmp (argv[i], "ln"))     { type = DB_STACK_UNARY; goto gotit; }
     31    if (!strcmp (argv[i], "sqrt"))   { type = DB_STACK_UNARY; goto gotit; }
     32    if (!strcmp (argv[i], "erf"))    { type = DB_STACK_UNARY; goto gotit; }
     33    if (!strcmp (argv[i], "sinh"))   { type = DB_STACK_UNARY; goto gotit; }
     34    if (!strcmp (argv[i], "cosh"))   { type = DB_STACK_UNARY; goto gotit; }
     35    if (!strcmp (argv[i], "asinh"))  { type = DB_STACK_UNARY; goto gotit; }
     36    if (!strcmp (argv[i], "acosh"))  { type = DB_STACK_UNARY; goto gotit; }
     37    if (!strcmp (argv[i], "sin"))    { type = DB_STACK_UNARY; goto gotit; }
     38    if (!strcmp (argv[i], "cos"))    { type = DB_STACK_UNARY; goto gotit; }
     39    if (!strcmp (argv[i], "tan"))    { type = DB_STACK_UNARY; goto gotit; }
     40    if (!strcmp (argv[i], "dsin"))   { type = DB_STACK_UNARY; goto gotit; }
     41    if (!strcmp (argv[i], "dcos"))   { type = DB_STACK_UNARY; goto gotit; }
     42    if (!strcmp (argv[i], "dtan"))   { type = DB_STACK_UNARY; goto gotit; }
     43    if (!strcmp (argv[i], "asin"))   { type = DB_STACK_UNARY; goto gotit; }
     44    if (!strcmp (argv[i], "acos"))   { type = DB_STACK_UNARY; goto gotit; }
     45    if (!strcmp (argv[i], "atan"))   { type = DB_STACK_UNARY; goto gotit; }
     46    if (!strcmp (argv[i], "dasin"))  { type = DB_STACK_UNARY; goto gotit; }
     47    if (!strcmp (argv[i], "dacos"))  { type = DB_STACK_UNARY; goto gotit; }
     48    if (!strcmp (argv[i], "datan"))  { type = DB_STACK_UNARY; goto gotit; }
     49    if (!strcmp (argv[i], "lgamma")) { type = DB_STACK_UNARY; goto gotit; }
     50    if (!strcmp (argv[i], "rnd"))    { type = DB_STACK_UNARY; goto gotit; }
     51    if (!strcmp (argv[i], "xramp"))  { type = DB_STACK_UNARY; goto gotit; }
     52    if (!strcmp (argv[i], "yramp"))  { type = DB_STACK_UNARY; goto gotit; }
     53    if (!strcmp (argv[i], "ramp"))   { type = DB_STACK_UNARY; goto gotit; }
     54    if (!strcmp (argv[i], "zero"))   { type = DB_STACK_UNARY; goto gotit; }
     55    if (!strcmp (argv[i], "--"))     { type = DB_STACK_UNARY; goto gotit; }
     56    if (!strcmp (argv[i], "not"))    { type = DB_STACK_UNARY; goto gotit; }
     57    if (!strcmp (argv[i], "isinf"))  { type = DB_STACK_UNARY; goto gotit; }
     58    if (!strcmp (argv[i], "isnan"))  { type = DB_STACK_UNARY; goto gotit; }
    6359
    6460    /* binary operations */
    65     if (!strcmp (argv[i], "^"))      { type = 8; goto gotit; }
    66 
    67     if (!strcmp (argv[i], "@"))      { type = 7; goto gotit; }
    68     if (!strcmp (argv[i], "/"))      { type = 7; goto gotit; }
    69     if (!strcmp (argv[i], "*"))      { type = 7; goto gotit; }
    70     if (!strcmp (argv[i], "%"))      { type = 7; goto gotit; }
    71 
    72     if (!strcmp (argv[i], "+"))      { type = 6; goto gotit; }
    73     if (!strcmp (argv[i], "-"))      { type = 6; goto gotit; }
     61    if (!strcmp (argv[i], "^"))      { type = DB_STACK_POWER; goto gotit; }
     62
     63    if (!strcmp (argv[i], "@"))      { type = DB_STACK_MULTIPLY; goto gotit; }
     64    if (!strcmp (argv[i], "/"))      { type = DB_STACK_MULTIPLY; goto gotit; }
     65    if (!strcmp (argv[i], "*"))      { type = DB_STACK_MULTIPLY; goto gotit; }
     66    if (!strcmp (argv[i], "%"))      { type = DB_STACK_MULTIPLY; goto gotit; }
     67
     68    if (!strcmp (argv[i], "+"))      { type = DB_STACK_SUM; goto gotit; }
     69    if (!strcmp (argv[i], "-"))      { type = DB_STACK_SUM; goto gotit; }
    7470       
    75     if (!strcmp (argv[i], "&"))      { type = 5; goto gotit; }
    76     if (!strcmp (argv[i], "|"))      { type = 5; goto gotit; }
    77 
    78     if (!strcmp (argv[i], "<"))      { type = 4; goto gotit; }
    79     if (!strcmp (argv[i], ">"))      { type = 4; goto gotit; }
    80     if (!strcmp (argv[i], "=="))     { type = 4; strcpy (argv[i], "E"); goto gotit; }
    81     if (!strcmp (argv[i], "!="))     { type = 4; strcpy (argv[i], "N"); goto gotit; }
    82     if (!strcmp (argv[i], "<="))     { type = 4; strcpy (argv[i], "L"); goto gotit; }
    83     if (!strcmp (argv[i], ">="))     { type = 4; strcpy (argv[i], "G"); goto gotit; }
    84     if (!strcmp (argv[i], ">>"))     { type = 4; strcpy (argv[i], "U"); goto gotit; }
    85     if (!strcmp (argv[i], "<<"))     { type = 4; strcpy (argv[i], "D"); goto gotit; }
    86 
    87     if (!strcmp (argv[i], "&&"))     { type = 3; strcpy (argv[i], "A"); goto gotit; }
    88     if (!strcmp (argv[i], "||"))     { type = 3; strcpy (argv[i], "O"); goto gotit; }
    89 
    90     if (!strcmp (argv[i], "("))      { type = 2; goto gotit; }
    91     if (!strcmp (argv[i], ")"))      { type = 1; goto gotit; }
     71    if (!strcmp (argv[i], "&"))      { type = DB_STACK_BITWISE; goto gotit; }
     72    if (!strcmp (argv[i], "|"))      { type = DB_STACK_BITWISE; goto gotit; }
     73
     74    if (!strcmp (argv[i], "<"))      { type = DB_STACK_COMPARE; goto gotit; }
     75    if (!strcmp (argv[i], ">"))      { type = DB_STACK_COMPARE; goto gotit; }
     76    if (!strcmp (argv[i], "=="))     { type = DB_STACK_COMPARE; strcpy (argv[i], "E"); goto gotit; }
     77    if (!strcmp (argv[i], "!="))     { type = DB_STACK_COMPARE; strcpy (argv[i], "N"); goto gotit; }
     78    if (!strcmp (argv[i], "<="))     { type = DB_STACK_COMPARE; strcpy (argv[i], "L"); goto gotit; }
     79    if (!strcmp (argv[i], ">="))     { type = DB_STACK_COMPARE; strcpy (argv[i], "G"); goto gotit; }
     80    if (!strcmp (argv[i], ">>"))     { type = DB_STACK_COMPARE; strcpy (argv[i], "U"); goto gotit; }
     81    if (!strcmp (argv[i], "<<"))     { type = DB_STACK_COMPARE; strcpy (argv[i], "D"); goto gotit; }
     82
     83    if (!strcmp (argv[i], "&&"))     { type = DB_STACK_LOGIC; strcpy (argv[i], "A"); goto gotit; }
     84    if (!strcmp (argv[i], "||"))     { type = DB_STACK_LOGIC; strcpy (argv[i], "O"); goto gotit; }
     85
     86    if (!strcmp (argv[i], "("))      { type = DB_STACK_OPEN_PAR; goto gotit; }
     87    if (!strcmp (argv[i], ")"))      { type = DB_STACK_CLOSE_PAR; goto gotit; }
    9288
    9389  gotit:
    9490    /* choose how to deal with object */
    9591    switch (type) {
    96       case 8:  /* exponentiation: 2^2^3 = 64 != 256 (precedence is right-to-left, not left-to-right!) */
     92      case DB_STACK_POWER:  /* exponentiation: 2^2^3 = 64 != 256 (precedence is right-to-left, not left-to-right!) */
    9793        /* pop previous, higher operators from OP stack to stack */
    9894        for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type > type); j--) {
    … …  
    107103        Nop_stack ++;
    108104        break;
    109       case 9: /* unary OPs */
    110       case 7: /* binary OPs */
    111       case 6:
    112       case 5:
    113       case 4:
    114       case 3:
     105      case DB_STACK_UNARY: /* unary OPs */
     106      case DB_STACK_MULTIPLY: /* binary OPs */
     107      case DB_STACK_SUM:
     108      case DB_STACK_BITWISE:
     109      case DB_STACK_COMPARE:
     110      case DB_STACK_LOGIC:
    115111        /* pop previous, higher or equal operators from OP stack to stack */
    116112        for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type >= type); j--) {
    … …  
    125121        Nop_stack ++;
    126122        break;
    127       case 2: 
     123      case DB_STACK_OPEN_PAR: 
    128124        /* push operator on OP stack */
    129125        op_stack[Nop_stack].name = strcreate (argv[i]);
    … …  
    131127        Nop_stack ++;
    132128        break;
    133       case 1:
     129      case DB_STACK_CLOSE_PAR:
    134130        /* pop rest of operators from OP stack to stack, looking for '(' */
    135         for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type != 2); j--) {
     131        for (j = Nop_stack - 1; (j >= 0) && (op_stack[j].type != DB_STACK_OPEN_PAR); j--) {
    136132          stack[Nstack] = op_stack[j];
    137133          op_stack[j].name = NULL;
    … …  
    139135          Nop_stack --;
    140136        }
    141         if ((j == -1) || (op_stack[j].type != 2)) {
     137        if ((j == -1) || (op_stack[j].type != DB_STACK_OPEN_PAR)) {
    142138          push_error ("syntax error: mismatched parenthesis");
    143139          Nstack = 0;
    … …  
    150146        /* value of 'X' is used as sentinel until we sort out values */
    151147        stack[Nstack].name = strcreate (argv[i]);
    152         stack[Nstack].type = 'X';
     148        stack[Nstack].type = DB_STACK_VALUE;
    153149        Nstack ++;
    154150        break;
    … …  
    156152  }
    157153
    158   /* dump remaining operators on stack, checking for ')' */
     154  /* dump remaining operators on stack, checking for '(' */
    159155  for (j = Nop_stack - 1; j >= 0; j--) {
    160     if (op_stack[j].type == 2) {
     156    if (op_stack[j].type == DB_STACK_OPEN_PAR) {
    161157      push_error ("syntax error: mismatched parenthesis");
    162158      Nstack = 0;

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

    r15718 r20936  
    44static int NallocUnary = 0;
    55
    6 dbStack *dbBinary (dbStack *V1, dbStack *V2, char *op, float *fields) {
     6dbStack *dbBinary (dbStack *V1, dbStack *V2, char *op, dbValue *fields) {
    77
    8   int N;
    9   float M1, M2;
    108  dbStack *OUT;
    119 
    12   if (V1->type == 'F') {
    13     N = V1->field;
    14     M1 = fields[N];
    15   } else {
    16     M1 = V1->Float;
    17   }
    18  
    19   if (V2->type == 'F') {
    20     N = V2->field;
    21     M2 = fields[N];
    22   } else {
    23     M2 = V2->Float;
     10# define SS_FUNC(OP) {                                                  \
     11    if (!(V1->type & DB_STACK_INT) && !(V2->type & DB_STACK_INT)) {     \
     12      opihi_flt M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Flt : V1->FltValue; \
     13      opihi_flt M2 = (V2->type & DB_STACK_FIELD) ? fields[V2->field].Flt : V2->FltValue; \
     14      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP;                     \
     15      OUT[0].FltValue = OP;                                             \
     16      break;                                                            \
     17    }                                                                   \
     18    if ((V1->type & DB_STACK_INT) && !(V2->type & DB_STACK_INT)) {      \
     19      opihi_int M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Int : V1->IntValue; \
     20      opihi_flt M2 = (V2->type & DB_STACK_FIELD) ? fields[V2->field].Flt : V2->FltValue; \
     21      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP;                     \
     22      OUT[0].FltValue = OP;                                             \
     23      break;                                                            \
     24    }                                                                   \
     25    if (!(V1->type & DB_STACK_INT) && (V2->type & DB_STACK_INT)) {      \
     26      opihi_flt M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Flt : V1->FltValue; \
     27      opihi_int M2 = (V2->type & DB_STACK_FIELD) ? fields[V2->field].Int : V2->IntValue; \
     28      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP;                     \
     29      OUT[0].FltValue = OP;                                             \
     30      break;                                                            \
     31    }                                                                   \
     32    if ((V1->type & DB_STACK_INT) && (V2->type & DB_STACK_INT)) {       \
     33      opihi_int M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Int : V1->IntValue; \
     34      opihi_int M2 = (V2->type & DB_STACK_FIELD) ? fields[V2->field].Int : V2->IntValue; \
     35      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP | DB_STACK_INT;      \
     36      OUT[0].IntValue = OP;                                             \
     37      break;                                                            \
     38    }                                                                   \
    2439  }
    2540
    2641  NallocBinary ++;
    2742  ALLOCATE (OUT, dbStack, 1);
    28   OUT->type = 'T';
    2943  OUT->name = NULL;
    3044
    31   // use an enum for the op...
     45  // XXX use an enum for the op...
    3246  switch (op[0]) {
    33   case '+':
    34     OUT->Float = M1 + M2;
    35     break;
    36   case '-':
    37     OUT->Float = M1 - M2;
    38     break;
    39   case '*':
    40     OUT->Float = M1 * M2;
    41     break;
    42   case '/':
    43     OUT->Float = M1 / M2;
    44     break;
    45   case '%':
    46     OUT->Float = (int) M1 % (int) M2;
    47     break;
    48   case 0x5e:
    49     OUT->Float = pow (M1, M2);
    50     break;
    51   case 'D':
    52     OUT->Float = MIN (M1, M2);
    53     break;
    54   case 'U':
    55     OUT->Float = MAX (M1, M2);
    56     break;
    57   case '<':
    58     OUT->Float = (M1 < M2) ? 1 : 0;
    59     break;
    60   case '>':
    61     OUT->Float = (M1 > M2) ? 1 : 0;
    62     break;
    63   case '&':
    64     OUT->Float = ((int)M1 & (int)M2);
    65     break;
    66   case '|':
    67     OUT->Float = ((int)M1 | (int)M2);
    68     break;
    69   case 'E':
    70     OUT->Float = (M1 == M2) ? 1 : 0;
    71     break;
    72   case 'N':
    73     OUT->Float = (M1 != M2) ? 1 : 0;
    74     break;
    75   case 'L':
    76     OUT->Float = (M1 <= M2) ? 1 : 0;
    77     break;
    78   case 'G':
    79     OUT->Float = (M1 >= M2) ? 1 : 0;
    80     break;
    81   case 'A':
    82     OUT->Float = (M1 && M2) ? 1 : 0;
    83     break;
    84   case 'O':
    85     OUT->Float = (M1 || M2) ? 1 : 0;
    86     break;
     47    case '+': SS_FUNC(M1 + M2);
     48    case '-': SS_FUNC(M1 - M2);
     49    case '*': SS_FUNC(M1 * M2);
     50    case '/': SS_FUNC(M1 / M2);
     51    case '%': SS_FUNC((int) M1 % (int) M2);
     52    case '^': SS_FUNC(pow (M1, M2));
     53    case 'D': SS_FUNC(MIN (M1, M2));
     54    case 'U': SS_FUNC(MAX (M1, M2));
     55    case '<': SS_FUNC((M1 < M2) ? 1 : 0);
     56    case '>': SS_FUNC((M1 > M2) ? 1 : 0);
     57    case '&': SS_FUNC(((int)M1 & (int)M2));
     58    case '|': SS_FUNC(((int)M1 | (int)M2));
     59    case 'E': SS_FUNC((M1 == M2) ? 1 : 0);
     60    case 'N': SS_FUNC((M1 != M2) ? 1 : 0);
     61    case 'L': SS_FUNC((M1 <= M2) ? 1 : 0);
     62    case 'G': SS_FUNC((M1 >= M2) ? 1 : 0);
     63    case 'A': SS_FUNC((M1 && M2) ? 1 : 0);
     64    case 'O': SS_FUNC((M1 || M2) ? 1 : 0);
    8765  default:
    8866    return (NULL);
    8967  }
    90 
     68# undef SS_FUNC
     69 
    9170  return (OUT);
    9271}
    9372
    94 dbStack *dbUnary (dbStack *V1, char *op, float *fields) {
     73dbStack *dbUnary (dbStack *V1, char *op, dbValue *fields) {
    9574
    96   int N;
    97   float M1;
    9875  dbStack *OUT;
     76 
     77# define S_FUNC(OP,FTYPE) {                                             \
     78    if (!(V1->type & DB_STACK_INT)) {                                   \
     79      opihi_flt M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Flt : V1->FltValue; \
     80      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP;                     \
     81      OUT[0].FltValue = OP;                                             \
     82      return (OUT);                                                     \
     83    }                                                                   \
     84    if ((FTYPE != DB_STACK_INT) && (V1->type & DB_STACK_INT)) {         \
     85      opihi_int M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Int : V1->IntValue; \
     86      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP;                     \
     87      OUT[0].FltValue = OP;                                             \
     88      return (OUT);                                                     \
     89    }                                                                   \
     90    if ((FTYPE == DB_STACK_INT) && (V1->type & DB_STACK_INT)) {         \
     91      opihi_int M1 = (V1->type & DB_STACK_FIELD) ? fields[V1->field].Int : V1->IntValue; \
     92      OUT[0].type = DB_STACK_VALUE | DB_STACK_TEMP | DB_STACK_INT;      \
     93      OUT[0].IntValue = OP;                                             \
     94      return (OUT);                                                     \
     95    }                                                                   \
     96  }
    9997
    100   if (V1->type == 'F') {
    101     N = V1->field;
    102     M1 = fields[N];
    103   } else {
    104     M1 = V1->Float;
    105   }
    106  
    10798  NallocUnary ++;
    10899  ALLOCATE (OUT, dbStack, 1);
    109   OUT->type = 'T';
    110100  OUT->name = NULL;
    111101
    112   if (!strcmp (op, "="))      {   OUT->Float = M1;                 }
    113   if (!strcmp (op, "abs"))    {   OUT->Float = fabs(M1);           }
    114   if (!strcmp (op, "int"))    {   OUT->Float = (float)(int)(M1);   }
    115   if (!strcmp (op, "exp"))    {   OUT->Float = exp (M1);           }
    116   if (!strcmp (op, "ten"))    {   OUT->Float = pow (10.0,M1);      }
    117   if (!strcmp (op, "log"))    {   OUT->Float = log10 (M1);         }
    118   if (!strcmp (op, "ln"))     {   OUT->Float = log (M1);           }
    119   if (!strcmp (op, "sqrt"))   {   OUT->Float = sqrt (M1);          }
    120   if (!strcmp (op, "erf"))    {   OUT->Float = erf (M1);           }
    121                                                      
    122   if (!strcmp (op, "sinh"))   {   OUT->Float = sinh (M1);          }
    123   if (!strcmp (op, "cosh"))   {   OUT->Float = cosh (M1);          }
    124   if (!strcmp (op, "asinh"))  {   OUT->Float = asinh (M1);         }
    125   if (!strcmp (op, "acosh"))  {   OUT->Float = acosh (M1);         }
    126   if (!strcmp (op, "lgamma")) {   OUT->Float = lgamma (M1);        }
     102  if (!strcmp (op, "="))      S_FUNC(M1,0);
     103  if (!strcmp (op, "abs"))    S_FUNC(fabs(M1),0);
     104  if (!strcmp (op, "int"))    S_FUNC((int)(M1),DB_STACK_INT);
     105  if (!strcmp (op, "exp"))    S_FUNC(exp (M1),0);
     106  if (!strcmp (op, "ten"))    S_FUNC(pow (10.0,M1),0);
     107  if (!strcmp (op, "log"))    S_FUNC(log10 (M1),0);
     108  if (!strcmp (op, "ln"))     S_FUNC(log (M1),0);
     109  if (!strcmp (op, "sqrt"))   S_FUNC(sqrt (M1),0);
     110  if (!strcmp (op, "erf"))    S_FUNC(erf (M1),0);
    127111
    128   if (!strcmp (op, "sin"))    {   OUT->Float = sin (M1);           }
    129   if (!strcmp (op, "cos"))    {   OUT->Float = cos (M1);           }
    130   if (!strcmp (op, "tan"))    {   OUT->Float = tan (M1);           }
    131   if (!strcmp (op, "dsin"))   {   OUT->Float = sin (M1*RAD_DEG);   }
    132   if (!strcmp (op, "dcos"))   {   OUT->Float = cos (M1*RAD_DEG);   }
    133   if (!strcmp (op, "dtan"))   {   OUT->Float = tan (M1*RAD_DEG);   }
    134   if (!strcmp (op, "asin"))   {   OUT->Float = asin (M1);          }
    135   if (!strcmp (op, "acos"))   {   OUT->Float = acos (M1);          }
    136   if (!strcmp (op, "atan"))   {   OUT->Float = atan (M1);          }
    137   if (!strcmp (op, "dasin"))  {   OUT->Float = asin (M1)*DEG_RAD;  }
    138   if (!strcmp (op, "dacos"))  {   OUT->Float = acos (M1)*DEG_RAD;  }
    139   if (!strcmp (op, "datan"))  {   OUT->Float = atan (M1)*DEG_RAD;  }
    140   if (!strcmp (op, "rnd"))    {   OUT->Float = drand48();          }
    141   if (!strcmp (op, "not"))    {   OUT->Float = !(M1);              }
    142   if (!strcmp (op, "--"))     {   OUT->Float = - (M1);             }
    143   if (!strcmp (op, "isinf"))  {   OUT->Float = !finite(M1);        }
    144   if (!strcmp (op, "isnan"))  {   OUT->Float = isnan(M1);          }
     112  if (!strcmp (op, "sinh"))   S_FUNC(sinh (M1),0);
     113  if (!strcmp (op, "cosh"))   S_FUNC(cosh (M1),0);
     114  if (!strcmp (op, "asinh"))  S_FUNC(asinh (M1),0);
     115  if (!strcmp (op, "acosh"))  S_FUNC(acosh (M1),0);
     116  if (!strcmp (op, "lgamma")) S_FUNC(lgamma (M1),0);
     117
     118  if (!strcmp (op, "sin"))    S_FUNC(sin (M1),0);
     119  if (!strcmp (op, "cos"))    S_FUNC(cos (M1),0);
     120  if (!strcmp (op, "tan"))    S_FUNC(tan (M1),0);
     121  if (!strcmp (op, "dsin"))   S_FUNC(sin (M1*RAD_DEG),0);
     122  if (!strcmp (op, "dcos"))   S_FUNC(cos (M1*RAD_DEG),0);
     123  if (!strcmp (op, "dtan"))   S_FUNC(tan (M1*RAD_DEG),0);
     124  if (!strcmp (op, "asin"))   S_FUNC(asin (M1),0);
     125  if (!strcmp (op, "acos"))   S_FUNC(acos (M1),0);
     126  if (!strcmp (op, "atan"))   S_FUNC(atan (M1),0);
     127  if (!strcmp (op, "dasin"))  S_FUNC(asin (M1)*DEG_RAD,0);
     128  if (!strcmp (op, "dacos"))  S_FUNC(acos (M1)*DEG_RAD,0);
     129  if (!strcmp (op, "datan"))  S_FUNC(atan (M1)*DEG_RAD,0);
     130  if (!strcmp (op, "rnd"))    S_FUNC(M1*0.0 + drand48(),0);
     131  if (!strcmp (op, "not"))    S_FUNC(!(M1),DB_STACK_INT);
     132  if (!strcmp (op, "--"))     S_FUNC(- (M1),DB_STACK_INT);
     133  if (!strcmp (op, "isinf"))  S_FUNC(!finite(M1),DB_STACK_INT);
     134  if (!strcmp (op, "isnan"))  S_FUNC(isnan(M1),DB_STACK_INT);
    145135
    146136  return (OUT);

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

    r15719 r20936  
    22
    33void dbInitStack (dbStack *stack) {
    4   stack[0].type   = 0;
     4  stack[0].type   = DB_STACK_NONE;
    55  stack[0].name   = NULL;
    66}
    … …  
    3434void dbFreeTempEntry (dbStack *stack) {
    3535
    36   if (stack->type != 'T') return;
     36  if (!(stack->type & DB_STACK_TEMP)) return;
    3737
    3838  if (stack[0].name != NULL)  free (stack[0].name);

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

    r14590 r20936  
    1515  int Type, mode, CCD;
    1616  int NVALUE;
    17   float *value;
     17  opihi_flt *value;
    1818  time_t TimeReference;
    1919  int TimeFormat;
    … …  
    151151  N = 0;
    152152  NVALUE = 1000;
    153   REALLOCATE (vec[0].elements, float, NVALUE);
    154   value = vec[0].elements;
     153  ResetVector (vec, OPIHI_FLT, NVALUE);
     154  value = vec[0].elements.Flt;
    155155
    156156  GetTimeFormat (&TimeReference, &TimeFormat);
    … …  
    193193    if (N >= NVALUE - 1) {
    194194      NVALUE += 1000;
    195       REALLOCATE (vec[0].elements, float, NVALUE);
    196       value = vec[0].elements;
    197     }
    198   }
    199 
    200   REALLOCATE (vec[0].elements, float, MAX (1,N));
     195      REALLOCATE (vec[0].elements.Flt, opihi_flt, NVALUE);
     196      value = vec[0].elements.Flt;
     197    }
     198  }
     199
     200  REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX (1,N));
    201201  vec[0].Nelements = N;
    202202

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

    r16810 r20936  
    1717  char name[64], filename[64], plotname[64], label[64];
    1818  double *M1, *M2;
    19   float *out, *colorFit, *deltaFit, dColor, C0, C1;
    20   float minDelta, maxDelta, minColor, maxColor;
     19  float *out;
     20  float *colorFit, *deltaFit, dColor, C0, C1;
     21  opihi_flt minDelta, maxDelta, minColor, maxColor;
    2122  int kapa, Npx, Npy, NPX, NPY, Nplot, PLOT;
    2223  Graphdata graphdata;
    … …  
    176177  /* vectors to save data */
    177178  Npts = 0;
    178   NPTS = 1;
     179  NPTS = 64;
    179180  if ((xvec = SelectVector ("tmp_x", ANYVECTOR, TRUE)) == NULL) goto escape;
    180181  if ((yvec = SelectVector ("tmp_y", ANYVECTOR, TRUE)) == NULL) goto escape;
     182
     183  ResetVector (xvec, OPIHI_FLT, NPTS);
     184  ResetVector (yvec, OPIHI_FLT, NPTS);
    181185
    182186  // set up basic windows
    … …  
    232236              if (M2[i2] < minColor) continue;
    233237              if (M2[i2] > maxColor) continue;
    234               yvec[0].elements[Npts] = M1[i1];
    235               xvec[0].elements[Npts] = M2[i2];
     238              yvec[0].elements.Flt[Npts] = M1[i1];
     239              xvec[0].elements.Flt[Npts] = M2[i2];
    236240              Npts++;
    237241              if (Npts >= NPTS) {
    238242                NPTS += 2000;
    239                 REALLOCATE (xvec[0].elements, float, NPTS);
    240                 REALLOCATE (yvec[0].elements, float, NPTS);
     243                REALLOCATE (xvec[0].elements.Flt, opihi_flt, NPTS);
     244                REALLOCATE (yvec[0].elements.Flt, opihi_flt, NPTS);
    241245              }
    242246            }
    … …  
    305309        KapaSetLimits (kapa, &graphdata);
    306310        KapaBox (kapa, &graphdata);
    307         KapaPrepPlot (kapa, Npts, &graphdata);
    308         KapaPlotVector (kapa, Npts, xvec[0].elements, "x");
    309         KapaPlotVector (kapa, Npts, yvec[0].elements, "y");
     311
     312        PlotVectorPair (kapa, xvec, yvec, &graphdata);
    310313
    311314        for (i = 0; i < 11; i++) {
    … …  
    314317        graphdata.style = 0;
    315318        graphdata.color = KapaColorByName ("red");
     319
    316320        KapaPrepPlot (kapa, 11, &graphdata);
    317321        KapaPlotVector (kapa, 11, colorFit, "x");

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

    r19823 r20936  
    136136    N = 0;
    137137    NPTS = 1000;
    138     ALLOCATE (vec1[0].elements, float, NPTS);
    139     ALLOCATE (vec2[0].elements, float, NPTS);
    140     ALLOCATE (vec3[0].elements, float, NPTS);
    141     ALLOCATE (vec4[0].elements, float, NPTS);
     138    ResetVector (vec1, OPIHI_FLT, NPTS);
     139    ResetVector (vec2, OPIHI_FLT, NPTS);
     140    ResetVector (vec3, OPIHI_FLT, NPTS);
     141    ResetVector (vec4, OPIHI_FLT, NPTS);
    142142  }
    143143
    … …  
    250250         
    251251          if (SaveVectors) {
    252             vec1[0].elements[N] = Mcat;
    253             vec2[0].elements[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
    254             vec3[0].elements[N] = catalog.measure[m].airmass;
    255             vec4[0].elements[N] = catalog.measure[m].photcode;
     252            vec1[0].elements.Flt[N] = Mcat;
     253            vec2[0].elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
     254            vec3[0].elements.Flt[N] = catalog.measure[m].airmass;
     255            vec4[0].elements.Flt[N] = catalog.measure[m].photcode;
    256256            N ++;
    257257            if (N == NPTS - 1) {
    258258              NPTS += 2000;
    259               REALLOCATE (vec1[0].elements, float, NPTS);
    260               REALLOCATE (vec2[0].elements, float, NPTS);
    261               REALLOCATE (vec3[0].elements, float, NPTS);
    262               REALLOCATE (vec4[0].elements, float, NPTS);
     259              REALLOCATE (vec1[0].elements.Flt, opihi_flt, NPTS);
     260              REALLOCATE (vec2[0].elements.Flt, opihi_flt, NPTS);
     261              REALLOCATE (vec3[0].elements.Flt, opihi_flt, NPTS);
     262              REALLOCATE (vec4[0].elements.Flt, opihi_flt, NPTS);
    263263            }
    264264          }

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

    r19823 r20936  
    113113
    114114  npts = NPTS = 200;
    115   ALLOCATE (Xvec.elements, float, NPTS);
    116   ALLOCATE (Yvec.elements, float, NPTS);
     115  SetVector (&Xvec, OPIHI_FLT, NPTS);
     116  SetVector (&Yvec, OPIHI_FLT, NPTS);
     117
    117118  ALLOCATE (plist, int, NPTS);
    118119  n = N = 0;
    … …  
    238239    status = FALSE;
    239240    for (j = 0; j < Npts; j++) {
    240       status |= fRD_to_XY (&Xvec.elements[N+2*j], &Yvec.elements[N+2*j], r[j], d[j], &graphmode.coords);
     241      status |= RD_to_XY (&Xvec.elements.Flt[N+2*j], &Yvec.elements.Flt[N+2*j], r[j], d[j], &graphmode.coords);
    241242      if (j > 0) {
    242         Xvec.elements[N+2*j - 1] = Xvec.elements[N+2*j];
    243         Yvec.elements[N+2*j - 1] = Yvec.elements[N+2*j];
     243        Xvec.elements.Flt[N+2*j - 1] = Xvec.elements.Flt[N+2*j];
     244        Yvec.elements.Flt[N+2*j - 1] = Yvec.elements.Flt[N+2*j];
    244245      }
    245246    }
    246     Xvec.elements[N+2*Npts-1] = Xvec.elements[N];
    247     Yvec.elements[N+2*Npts-1] = Yvec.elements[N];
     247    Xvec.elements.Flt[N+2*Npts-1] = Xvec.elements.Flt[N];
     248    Yvec.elements.Flt[N+2*Npts-1] = Yvec.elements.Flt[N];
    248249    if (!status) continue;
    249250    // if none of the points are on the visible side of the projection, do not plot the image
    … …  
    251252    InPic = FALSE;
    252253    for (j = 0; j < 2*Npts; j+=2) {
    253       if ((Xvec.elements[N+j] >= graphmode.xmin) &&
    254           (Xvec.elements[N+j] <= graphmode.xmax) &&
    255           (Yvec.elements[N+j] >= graphmode.ymin) &&
    256           (Yvec.elements[N+j] <= graphmode.ymax))
     254      if ((Xvec.elements.Flt[N+j] >= graphmode.xmin) &&
     255          (Xvec.elements.Flt[N+j] <= graphmode.xmax) &&
     256          (Yvec.elements.Flt[N+j] >= graphmode.ymin) &&
     257          (Yvec.elements.Flt[N+j] <= graphmode.ymax))
    257258        InPic = TRUE;
    258259    }
    … …  
    269270    if (N + 16 >= NPTS) {  /* need to leave room for 8 point image */
    270271      NPTS += 400;
    271       REALLOCATE (Xvec.elements, float, NPTS);
    272       REALLOCATE (Yvec.elements, float, NPTS);
     272      REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     273      REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    273274    }
    274275  }
    275276
    276277  gprint (GP_ERR, "plotting %d images\n", n);
    277   Xvec.Nelements = Xvec.Nelements = N;
     278  Xvec.Nelements = Yvec.Nelements = N;
    278279  if (N > 0) {
    279280    graphmode.style = 2; /* points */
    280281    graphmode.ptype = 100; /* connect pairs of points */
    281282    graphmode.etype = 0;
    282     PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
    283   }
    284 
    285   free (Xvec.elements);
    286   free (Yvec.elements);
     283    PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
     284  }
     285
     286  free (Xvec.elements.Flt);
     287  free (Yvec.elements.Flt);
    287288  free (image);
    288289  return (TRUE);

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

    r20212 r20936  
    3636 
    3737  /* project this image to screen display coords */
    38   ALLOCATE (Xvec.elements, float, 8);
    39   ALLOCATE (Yvec.elements, float, 8);
     38  SetVector (&Xvec, OPIHI_FLT, 8);
     39  SetVector (&Yvec, OPIHI_FLT, 8);
    4040
    4141  while (gfits_fread_header (f, &header)) {
    … …  
    8282        while (r > Rmid) r-= 360.0;
    8383      }
    84       status |= fRD_to_XY (&Xvec.elements[2*j], &Yvec.elements[2*j], r, d, &graphmode.coords);
     84      status |= RD_to_XY (&Xvec.elements.Flt[2*j], &Yvec.elements.Flt[2*j], r, d, &graphmode.coords);
    8585      if (j > 0) {
    86         Xvec.elements[2*j - 1] = Xvec.elements[2*j];
    87         Yvec.elements[2*j - 1] = Yvec.elements[2*j];
     86        Xvec.elements.Flt[2*j - 1] = Xvec.elements.Flt[2*j];
     87        Yvec.elements.Flt[2*j - 1] = Yvec.elements.Flt[2*j];
    8888      }
    8989    }
    90     Xvec.elements[7] = Xvec.elements[0];
    91     Yvec.elements[7] = Yvec.elements[0];
     90    Xvec.elements.Flt[7] = Xvec.elements.Flt[0];
     91    Yvec.elements.Flt[7] = Yvec.elements.Flt[0];
    9292    InPic = FALSE;
    9393    for (j = 0; j < 8; j+=2) {
    94       if ((Xvec.elements[j] >= graphmode.xmin) &&
    95           (Xvec.elements[j] <= graphmode.xmax) &&
    96           (Yvec.elements[j] >= graphmode.ymin) &&
    97           (Yvec.elements[j] <= graphmode.ymax))
     94      if ((Xvec.elements.Flt[j] >= graphmode.xmin) &&
     95          (Xvec.elements.Flt[j] <= graphmode.xmax) &&
     96          (Yvec.elements.Flt[j] >= graphmode.ymin) &&
     97          (Yvec.elements.Flt[j] <= graphmode.ymax))
    9898        InPic = TRUE;
    9999    }
    100100
    101     Xvec.Nelements = Xvec.Nelements = 8;
     101    Xvec.Nelements = Yvec.Nelements = 8;
    102102    if (InPic) {
    103103      graphmode.style = 2; /* points */
    104104      graphmode.ptype = 100; /* connect pairs of points */
    105105      graphmode.etype = 0;
    106       PlotVectorPair (kapa, 8, Xvec.elements, Yvec.elements, &graphmode);
     106      PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    107107    }
    108108  skip:
    … …  
    112112  }
    113113  fclose (f);
    114   free (Xvec.elements);
    115   free (Yvec.elements);
     114  free (Xvec.elements.Flt);
     115  free (Yvec.elements.Flt);
    116116  return (TRUE);
    117117

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

    r20535 r20936  
    4949
    5050  gprint (GP_ERR, "function is poorly defined; disabled and may be removed\n");
     51  gprint (GP_ERR, "this function extracts measure data corresponding to a given image?\n");
    5152  return (FALSE);
    5253
    … …  
    124125 
    125126  /* create output vector */
     127  N = 0;
    126128  NPTS = 1000;
    127   REALLOCATE (vec[0].elements, float, NPTS);
    128   vec[0].Nelements = N = 0;
     129  ResetVector (vec, OPIHI_FLT, NPTS);
    129130
    130131  // prepare to handle interrupt signals
    … …  
    153154          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    154155          n = catalog.measure[i].averef;
    155           vec[0].elements[N] = catalog.average[n].R - catalog.measure[i].dR / 3600.0;
    156           N++;
    157           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     156          vec[0].elements.Flt[N] = catalog.average[n].R - catalog.measure[i].dR / 3600.0;
     157          N++;
     158          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    158159        }
    159160        break;
    … …  
    162163          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    163164          n = catalog.measure[i].averef;
    164           vec[0].elements[N] = catalog.average[n].D - catalog.measure[i].dD / 3600.0;
    165           N++;
    166           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     165          vec[0].elements.Flt[N] = catalog.average[n].D - catalog.measure[i].dD / 3600.0;
     166          N++;
     167          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    167168        }
    168169        break;
    … …  
    170171        for (i = 0; i < catalog.Nmeasure; i++) {
    171172          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    172           vec[0].elements[N] = catalog.measure[i].M;
    173           N++;
    174           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     173          vec[0].elements.Flt[N] = catalog.measure[i].M;
     174          N++;
     175          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    175176        }
    176177        break;
    … …  
    178179        for (i = 0; i < catalog.Nmeasure; i++) {
    179180          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    180           vec[0].elements[N] = catalog.measure[i].dM;
    181           N++;
    182           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     181          vec[0].elements.Flt[N] = catalog.measure[i].dM;
     182          N++;
     183          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    183184        }
    184185        break;
    … …  
    186187        for (i = 0; i < catalog.Nmeasure; i++) {
    187188          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    188           vec[0].elements[N] = catalog.measure[i].Mcal;
    189           N++;
    190           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     189          vec[0].elements.Flt[N] = catalog.measure[i].Mcal;
     190          N++;
     191          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    191192        }
    192193        break;
    … …  
    195196          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    196197          n = catalog.measure[i].averef;
    197           // vec[0].elements[N] = catalog.average[n].M;
     198          // vec[0].elements.Flt[N] = catalog.average[n].M;
    198199          N++;
    199200        }
    … …  
    202203        for (i = 0; i < catalog.Nmeasure; i++) {
    203204          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    204           vec[0].elements[N] = catalog.measure[i].photcode;
    205           N++;
    206           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     205          vec[0].elements.Flt[N] = catalog.measure[i].photcode;
     206          N++;
     207          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    207208        }
    208209        break;
    … …  
    210211        for (i = 0; i < catalog.Nmeasure; i++) {
    211212          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    212           vec[0].elements[N] = TimeValue (catalog.measure[i].t, TimeReference, TimeFormat);
    213           N++;
    214           CHECK_REALLOCATE (vec[0].elements, float, NPTS, N, 1000);
     213          vec[0].elements.Flt[N] = TimeValue (catalog.measure[i].t, TimeReference, TimeFormat);
     214          N++;
     215          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    215216        }
    216217        break;
    … …  
    220221 
    221222  vec[0].Nelements = N;
    222   REALLOCATE (vec[0].elements, float, MAX(1,N));
     223  REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX(1,N));
    223224  return (TRUE);
    224225}

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

    r19823 r20936  
    3030  srand48(B);
    3131
     32  N = 0;
    3233  NPTS = 200;
    33   ALLOCATE (Xvec.elements, float, NPTS);
    34   ALLOCATE (Yvec.elements, float, NPTS);
    35   N = 0;
     34  SetVector (&Xvec, OPIHI_FLT, NPTS);
     35  SetVector (&Yvec, OPIHI_FLT, NPTS);
     36
    3637  for (i = 0; i < Nimage; i++) {
    3738    /* choose a position for point within image box */
    … …  
    4546    while (r < Rmin) r += 360.0;
    4647    while (r > Rmax) r -= 360.0;
    47     status |= fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], r, d, &graphmode.coords);
    48     if ((Xvec.elements[N] >= graphmode.xmin) &&
    49         (Xvec.elements[N] <= graphmode.xmax) &&
    50         (Yvec.elements[N] >= graphmode.ymin) &&
    51         (Yvec.elements[N] <= graphmode.ymax) && status) {
     48    status |= RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, d, &graphmode.coords);
     49    if ((Xvec.elements.Flt[N] >= graphmode.xmin) &&
     50        (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     51        (Yvec.elements.Flt[N] >= graphmode.ymin) &&
     52        (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
    5253      N++;
    5354      if (N > NPTS - 1) {
    5455        NPTS += 200;
    55         REALLOCATE (Xvec.elements, float, NPTS);
    56         REALLOCATE (Yvec.elements, float, NPTS);
     56        REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     57        REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    5758      }
    5859    }
    5960  }
    6061
    61   Xvec.Nelements = Xvec.Nelements = N;
     62  Xvec.Nelements = Yvec.Nelements = N;
    6263  if (N > 0) {
    6364    graphmode.style = 2; /* points */
    6465    graphmode.etype = 0;
    65     PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     66    PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    6667  }
    6768
    68   free (Xvec.elements);
    69   free (Yvec.elements);
     69  free (Xvec.elements.Flt);
     70  free (Yvec.elements.Flt);
    7071  free (image);
    7172  return (TRUE);

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

    r17246 r20936  
    11# include "dvoshell.h"
    22
    3 // need to upgrade this to support multiple fields and WHERE clauses
    4 
    5 enum {ZERO,
    6       RA,
    7       DEC,
    8       Xm,
    9       AIRMASS,
    10       MCAL,
    11       dMCAL,
    12       PHOTCODE,
    13       TIME,
    14       FWHM,
    15       EXPTIME,
    16       NSTAR,
    17       NCAL,
    18       SKY,
    19       FLAG,
    20       NX_PIX,
    21       NY_PIX,
    22       THETA,
    23       SKEW,
    24       SCALE,
    25       DSCALE,
    26       IMAGE_ID,
    27       X_LL_CHIP,
    28       X_LR_CHIP,
    29       X_UL_CHIP,
    30       X_UR_CHIP,
    31       Y_LL_CHIP,
    32       Y_LR_CHIP,
    33       Y_UL_CHIP,
    34       Y_UR_CHIP,
    35       X_LL_FP,
    36       X_LR_FP,
    37       X_UL_FP,
    38       X_UR_FP,
    39       Y_LL_FP,
    40       Y_LR_FP,
    41       Y_UL_FP,
    42       Y_UR_FP,
    43 };
    44 
    453int imextract (int argc, char **argv) {
    464 
    47   int i, j, Nimage, mode, N, PhotcodeSelect;
    48   int TimeSelect, *subset, Nsubset, TimeFormat, FlagSelect, FlagValue;
    49   double x, y, ra, dec, t, trange;
    50   time_t tzero, TimeReference;
     5  // int *subset, Nsubset;  -- not sure if we need to use this or not...
     6
     7  int i, j, n, N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
     8  int Nimage, VERBOSE;
     9  char **cstack, name[1024];
     10  void *Signal;
     11
     12  Vector **vec;
     13  Image *image;
     14  dbStack *stack;
     15  dbField *fields;
     16  dbValue *values;
    5117  SkyRegionSelection *selection;
    5218
    53   PhotCode *code;
    54   Image *image;
    55   Vector *vec;
    56 
    57   if (!InitPhotcodes ()) return (FALSE);
     19  /* defaults */
     20  vec = NULL;
     21  image = NULL;
     22  stack = NULL;
     23  fields = NULL;
     24  values = NULL;
     25  selection = NULL;
     26
     27  if ((N = get_argument (argc, argv, "-h"))) goto help;
     28  if ((N = get_argument (argc, argv, "--help"))) goto help;
     29
     30  VERBOSE = FALSE;
     31  if ((N = get_argument (argc, argv, "-v"))) {
     32    remove_argument (N, &argc, argv);
     33    VERBOSE = TRUE;
     34  }
     35
     36  if (!InitPhotcodes ()) goto escape;
    5837
    5938  // parse skyregion options
    6039  if ((selection = SetRegionSelection (&argc, argv)) == NULL) {
    6140    gprint (GP_ERR, "invalid sky region selection\n");
    62     return FALSE;
    63   }
    64 
    65   /* check for time-based selection */
    66   TimeSelect = FALSE;
    67   if ((N = get_argument (argc, argv, "-time"))) {
    68     remove_argument (N, &argc, argv);
    69     if (!ohana_str_to_time (argv[N], &tzero)) {
    70       gprint (GP_ERR, "syntax error\n");
    71       return (FALSE);
    72     }
    73     remove_argument (N, &argc, argv);
    74     if (!ohana_str_to_dtime (argv[N], &trange)) {
    75       gprint (GP_ERR, "syntax error\n");
    76       return (FALSE);
    77     }
    78     remove_argument (N, &argc, argv);
    79     TimeSelect = TRUE;
    80   }
    81 
    82   /* check for region-based selection */
    83   FlagValue = 0;
    84   FlagSelect = FALSE;
    85   if ((N = get_argument (argc, argv, "-flag"))) {
    86     remove_argument (N, &argc, argv);
    87     FlagValue = atoi (argv[N]);
    88     remove_argument (N, &argc, argv);
    89     FlagSelect = TRUE;
    90   }
    91 
    92   /* check for photcode-based selection */
    93   code = NULL;
    94   PhotcodeSelect = FALSE;
    95   if ((N = get_argument (argc, argv, "-photcode"))) {
    96     PhotcodeSelect = TRUE;
    97     remove_argument (N, &argc, argv);
    98     if ((code = GetPhotcodebyName (argv[N])) == NULL) {
    99       gprint (GP_ERR, "ERROR: photcode %s not found in photcode table\n", argv[N]);
    100       return (FALSE);
    101     }
    102     if ((code[0].type != PHOT_SEC) && (code[0].type != PHOT_DEP)) {
    103       gprint (GP_ERR, "photcode must be primary, secondary, or dependent code\n");
    104       return (FALSE);
    105     }
    106     remove_argument (N, &argc, argv);
    107   }
    108 
    109   if (argc != 2) {
    110     gprint (GP_ERR, "USAGE: imextract (value) [-region] [-time start range] [-photcode photcode]\n");
     41    goto escape;
     42  }
     43
     44  // command-line is of the form: imextract field,field, field [where (field op value)...]
     45
     46  // parse the fields to be extracted and returned
     47  fields = dbCmdlineFields (argc, argv, DVO_TABLE_IMAGE, &last, &Nfields);
     48  if (fields == NULL) goto escape;
     49  if (Nfields == 0) {
     50    FreeSkyRegionSelection (selection);
     51    dbFreeFields (fields, Nfields);
     52    goto help;
     53  }
     54
     55  // examine line for 'where' or 'match to'.  'match to' is forbidden
     56  state = dbCmdlineConditions (argc, argv, last, &next);
     57  if (state == DVO_DB_CMDLINE_ERROR) goto escape;
     58  if (state == DVO_DB_CMDLINE_IS_MATCH) goto escape; // not allowed for mextract
     59
     60  // parse the remainder of the line as a boolean math expression
     61  cstack = isolate_elements (argc-next, &argv[next], &Ncstack);
     62 
     63  // construct the db Boolean math stack (frees cstack)
     64  stack = dbRPN (Ncstack, cstack, &Nstack);
     65
     66  // add the skyregion limits to the where statement (or create)
     67  // XXX we may want to drop this and use just the image_subset function
     68  dbAstroRegionLimits (&stack, &Nstack, selection, DVO_TABLE_IMAGE);
     69
     70  // parse stack elements into fields and scalars as needed
     71  Nreturn = Nfields;
     72  if (!dbCheckStack (stack, Nstack, DVO_TABLE_IMAGE, &fields, &Nfields)) goto escape;
     73
     74  /* create output storage vectors */
     75  ALLOCATE (values, dbValue, Nfields);
     76  ALLOCATE (vec, Vector *, Nreturn);
     77  for (i = 0; i < Nreturn; i++) {
     78    if (ISNUM(fields[i].name[0])) {
     79      sprintf (name, "v_%s", fields[i].name);
     80    } else {
     81      sprintf (name, "%s", fields[i].name);
     82    }
     83    if ((vec[i] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) goto escape;
     84    ResetVector (vec[i], fields[i].type, NPTS);
     85  }
     86
     87  Npts = 0;
     88  NPTS = 1;
     89
     90  if ((image = LoadImages (&Nimage)) == NULL) goto escape;
     91  BuildChipMatch (image, Nimage);
     92  dbExtractImagesInit ();
     93
     94  // XXX do I need to use this, or the region portion
     95  // image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect);
     96
     97  // grab data from all selected sky regions
     98  Signal = signal (SIGINT, handle_interrupt);
     99  interrupt = FALSE;
     100  for (j = 0; (j < Nimage) && !interrupt; j++) {
     101
     102    // reset counters for saved fields, extract fields
     103    dbExtractImagesReset ();
     104    for (n = 0; n < Nfields; n++) {
     105      values[n] = dbExtractImages (image, Nimage, j, &fields[n]);
     106    }
     107
     108    // test the conditional statement
     109    if (!dbBooleanCond (stack, Nstack, values)) continue;
     110    for (n = 0; n < Nreturn; n++) {
     111      if (vec[n][0].type == OPIHI_FLT) {
     112        vec[n][0].elements.Flt[Npts] = values[n].Flt;
     113      } else {
     114        vec[n][0].elements.Int[Npts] = values[n].Int;
     115      }
     116    }
     117    Npts++;
     118    if (Npts >= NPTS) {
     119      NPTS += 2000;
     120      for (n = 0; n < Nreturn; n++) {
     121        if (vec[n][0].type == OPIHI_FLT) {
     122          REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
     123        } else {
     124          REALLOCATE (vec[n][0].elements.Int, opihi_int, NPTS);
     125        }
     126      }
     127    }
     128  }
     129  signal (SIGINT, Signal);
     130  interrupt = FALSE;
     131  for (n = 0; n < Nreturn; n++) {
     132    vec[n][0].Nelements = Npts;
     133    if (vec[n][0].type == OPIHI_FLT) {
     134      REALLOCATE (vec[n][0].elements.Flt, opihi_flt, MAX(1,Npts));
     135    } else {
     136      REALLOCATE (vec[n][0].elements.Int, opihi_int, MAX(1,Npts));
     137    }
     138  }
     139
     140  // free (subset);
     141  free (image);
     142
     143  if (vec) free (vec);
     144  if (values) free (values);
     145  dbFreeFields (fields, Nfields);
     146  dbFreeStack (stack, Nstack);
     147  if (stack) free (stack);
     148  return (TRUE);
     149 
     150 escape:
     151  if (vec) free (vec);
     152  if (values) free (values);
     153  dbFreeFields (fields, Nfields);
     154  dbFreeStack (stack, Nstack);
     155  if (stack) free (stack);
     156  return (FALSE);
     157
     158 help:
     159  gprint (GP_ERR, "USAGE: imextract field[,field,field...] where (expression)\n");
     160
     161  if ((argc > N + 1) && !strcasecmp (argv[N+1], "fields")) {
     162    gprint (GP_ERR, " USAGE: imextract field[,field,field...] where (expression)\n");
     163    gprint (GP_ERR, "  RA : right ascension of field center (J2000)\n");
     164    gprint (GP_ERR, "  DEC : declination of field center\n");
     165    gprint (GP_ERR, "  GLON : galactic longitude of field center (J2000)\n");
     166    gprint (GP_ERR, "  GLAT : galactic latitude of field center (J2000)\n");
     167    gprint (GP_ERR, "  ELON : ecliptic longitude of field center (J2000)\n");
     168    gprint (GP_ERR, "  ELAT : ecliptic latitude of field center (J2000)\n");
     169
     170    gprint (GP_ERR, "  theta : position angle of image\n");
     171    gprint (GP_ERR, "  skew : distortion from rectangle\n");
     172    gprint (GP_ERR, "  scale : pixel scale\n");
     173    gprint (GP_ERR, "  dscale : pixel-scale error (or variation?)\n");
     174
     175    gprint (GP_ERR, "  time : time of exposure\n");
     176    gprint (GP_ERR, "  nstar : number of stars detected in exposure\n");
     177    gprint (GP_ERR, "  airmass : mean airmass of exposure\n");
     178    gprint (GP_ERR, "  NX : image dimensions\n");
     179    gprint (GP_ERR, "  NY : image dimensions\n");
     180
     181    gprint (GP_ERR, "  apresid : aperture - fit magnitude\n");
     182    gprint (GP_ERR, "  dapresid : aperture - fit magnitude scatter\n");
     183
     184    gprint (GP_ERR, "  Mcal : photometry calibration (mags)\n");
     185    gprint (GP_ERR, "  dMcal : photometry calibration error (mags)\n");
     186    gprint (GP_ERR, "  Xm : chisq of photometry calibration\n");
     187    gprint (GP_ERR, "  photcode : numeric photcode value for image\n");
     188    gprint (GP_ERR, "  exptime : exposure duration (seconds)\n");
     189    gprint (GP_ERR, "  sidtime : sidereal time of exposure\n");
     190
     191    gprint (GP_ERR, "  latitude : observatory latitude\n");
     192
     193    gprint (GP_ERR, "  detlimit : detection limit of exposure\n");
     194    gprint (GP_ERR, "  satlimit : saturation limit of exposure\n");
     195    gprint (GP_ERR, "  cerror : astrometric scatter\n");
     196
     197    gprint (GP_ERR, "  FWHM : mean fwhm of exposure\n");
     198    gprint (GP_ERR, "  FWHM_MAJ : fwhm of major axis\n");
     199    gprint (GP_ERR, "  FWHM_MIN : fwhm of minor axis\n");
     200    gprint (GP_ERR, "  trate : tracking rate for TDI images\n");
     201
     202    gprint (GP_ERR, "  ncal : number of stars used for photometry calibration\n");
     203    gprint (GP_ERR, "  sky : mean background flux\n");
     204
     205    gprint (GP_ERR, "  flag : processing bit flags\n");
     206    gprint (GP_ERR, "  ccdnum : identifier for CCD\n");
     207
     208    gprint (GP_ERR, "  imageID  : unique image identifier\n");
     209    gprint (GP_ERR, "  externID : external image identifier\n");
     210    gprint (GP_ERR, "  sourceID : external db reference\n");
     211
     212    gprint (GP_ERR, "  X_LL_CHIP : chip x-pixel coordinate of lower left corner\n");
     213    gprint (GP_ERR, "  X_LR_CHIP : chip x-pixel coordinate of lower right corner\n");
     214    gprint (GP_ERR, "  X_UL_CHIP : chip x-pixel coordinate of upper left corner\n");
     215    gprint (GP_ERR, "  X_UR_CHIP : chip x-pixel coordinate of upper right corner\n");
     216    gprint (GP_ERR, "  Y_LL_CHIP : chip y-pixel coordinate of lower left corner\n");
     217    gprint (GP_ERR, "  Y_LR_CHIP : chip y-pixel coordinate of lower right corner\n");
     218    gprint (GP_ERR, "  Y_UL_CHIP : chip y-pixel coordinate of upper left corner\n");
     219    gprint (GP_ERR, "  Y_UR_CHIP : chip y-pixel coordinate of upper right corner\n");
     220    gprint (GP_ERR, "  X_LL_FP   : focal-plane x-pixel coordinate of lower left corner\n");
     221    gprint (GP_ERR, "  X_LR_FP   : focal-plane x-pixel coordinate of lower right corner\n");
     222    gprint (GP_ERR, "  X_UL_FP   : focal-plane x-pixel coordinate of upper left corner\n");
     223    gprint (GP_ERR, "  X_UR_FP   : focal-plane x-pixel coordinate of upper right corner\n");
     224    gprint (GP_ERR, "  Y_LL_FP   : focal-plane y-pixel coordinate of lower left corner\n");
     225    gprint (GP_ERR, "  Y_LR_FP   : focal-plane y-pixel coordinate of lower right corner\n");
     226    gprint (GP_ERR, "  Y_UL_FP   : focal-plane y-pixel coordinate of upper left corner\n");
     227    gprint (GP_ERR, "  Y_UR_FP   : focal-plane y-pixel coordinate of upper right corner\n");
    111228    return (FALSE);
    112229  }
    113  
    114   /* identify selection */
    115   mode = ZERO;
    116   if (!strcasecmp (argv[1], "ra"       )) mode = RA;
    117   if (!strcasecmp (argv[1], "dec"      )) mode = DEC;
    118   if (!strcasecmp (argv[1], "Xm"       )) mode = Xm;
    119   if (!strcasecmp (argv[1], "airmass"  )) mode = AIRMASS;
    120   if (!strcasecmp (argv[1], "Mcal"     )) mode = MCAL;
    121   if (!strcasecmp (argv[1], "dMcal"    )) mode = dMCAL;
    122   if (!strcasecmp (argv[1], "photcode" )) mode = PHOTCODE;
    123   if (!strcasecmp (argv[1], "time"     )) mode = TIME;
    124   if (!strcasecmp (argv[1], "FWHM"     )) mode = FWHM;
    125   if (!strcasecmp (argv[1], "exptime"  )) mode = EXPTIME;
    126   if (!strcasecmp (argv[1], "nstar"    )) mode = NSTAR;
    127   if (!strcasecmp (argv[1], "ncal"     )) mode = NCAL;
    128   if (!strcasecmp (argv[1], "sky"      )) mode = SKY;
    129   if (!strcasecmp (argv[1], "flag"     )) mode = FLAG;
    130   if (!strcasecmp (argv[1], "NX"       )) mode = NX_PIX;
    131   if (!strcasecmp (argv[1], "NY"       )) mode = NY_PIX;
    132   if (!strcasecmp (argv[1], "theta"    )) mode = THETA;
    133   if (!strcasecmp (argv[1], "skew"     )) mode = SKEW;
    134   if (!strcasecmp (argv[1], "scale"    )) mode = SCALE;
    135   if (!strcasecmp (argv[1], "dscale"   )) mode = DSCALE;
    136   if (!strcasecmp (argv[1], "imageID"  )) mode = IMAGE_ID;
    137   if (!strcasecmp (argv[1], "X_LL_CHIP")) mode = X_LL_CHIP;
    138   if (!strcasecmp (argv[1], "X_LR_CHIP")) mode = X_LR_CHIP;
    139   if (!strcasecmp (argv[1], "X_UL_CHIP")) mode = X_UL_CHIP;
    140   if (!strcasecmp (argv[1], "X_UR_CHIP")) mode = X_UR_CHIP;
    141   if (!strcasecmp (argv[1], "Y_LL_CHIP")) mode = Y_LL_CHIP;
    142   if (!strcasecmp (argv[1], "Y_LR_CHIP")) mode = Y_LR_CHIP;
    143   if (!strcasecmp (argv[1], "Y_UL_CHIP")) mode = Y_UL_CHIP;
    144   if (!strcasecmp (argv[1], "Y_UR_CHIP")) mode = Y_UR_CHIP;
    145   if (!strcasecmp (argv[1], "X_LL_FP"  )) mode = X_LL_FP;
    146   if (!strcasecmp (argv[1], "X_LR_FP"  )) mode = X_LR_FP;
    147   if (!strcasecmp (argv[1], "X_UL_FP"  )) mode = X_UL_FP;
    148   if (!strcasecmp (argv[1], "X_UR_FP"  )) mode = X_UR_FP;
    149   if (!strcasecmp (argv[1], "Y_LL_FP"  )) mode = Y_LL_FP;
    150   if (!strcasecmp (argv[1], "Y_LR_FP"  )) mode = Y_LR_FP;
    151   if (!strcasecmp (argv[1], "Y_UL_FP"  )) mode = Y_UL_FP;
    152   if (!strcasecmp (argv[1], "Y_UR_FP"  )) mode = Y_UR_FP;
    153   if (mode == ZERO) {
    154     gprint (GP_ERR, "value may be one of the following:\n");
    155     gprint (GP_ERR, " ra dec airmass Mcal dMcal Xm photcode time fwhm exptime nstar ncal sky flag\n");
    156     return (FALSE);
    157   }
    158   if ((vec = SelectVector (argv[1], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    159 
    160   if ((image = LoadImages (&Nimage)) == NULL) return (FALSE);
    161   image_subset (image, Nimage, &subset, &Nsubset, selection, tzero, trange, TimeSelect);
    162   if ((mode == RA) || (mode == DEC)) BuildChipMatch (image, Nimage);
    163 
    164   GetTimeFormat (&TimeReference, &TimeFormat);
    165 
    166   /* create storage vector */
    167   REALLOCATE (vec[0].elements, float, Nimage);
    168   vec[0].Nelements = Nimage;
    169  
    170   N = 0;
    171   /* assign vector values */
    172   for (i = 0; i < Nsubset; i++) {
    173     j = subset[i];
    174     if (PhotcodeSelect) {
    175       if (code[0].type == PHOT_DEP) {
    176         if (code[0].code != image[j].photcode) continue;
    177       } else {
    178         if (code[0].code != GetPhotcodeEquivCodebyCode (image[j].photcode)) continue;
    179       }
    180     }
    181     if (FlagSelect && (FlagValue != image[j].code)) continue;
    182     switch (mode) {
    183       case RA:
    184         if (!FindMosaicForImage (image, Nimage, j)) continue;
    185         x = 0.5*image[j].NX;
    186         y = 0.5*image[j].NY;
    187         XY_to_RD (&ra, &dec, x, y, &image[j].coords);
    188         vec[0].elements[N] = ra;
    189         break;
    190       case DEC:
    191         if (!FindMosaicForImage (image, Nimage, j)) continue;
    192         x = 0.5*image[j].NX;
    193         y = 0.5*image[j].NY;
    194         XY_to_RD (&ra, &dec, x, y, &image[j].coords);
    195         vec[0].elements[N] = dec;
    196         break;
    197       case Xm:
    198         vec[0].elements[N] = pow(10.0, 0.01*image[j].Xm);
    199         break;
    200       case AIRMASS:
    201         vec[0].elements[N] = image[j].secz;
    202         break;
    203       case MCAL:
    204         vec[0].elements[N] = image[j].Mcal;
    205         break;
    206       case dMCAL:
    207         vec[0].elements[N] = image[j].dMcal;
    208         break;
    209       case PHOTCODE:
    210         vec[0].elements[N] = image[j].photcode;
    211         break;
    212       case TIME:
    213         t = image[j].tzero + 0.5*image[j].NY * image[j].trate / 10000;
    214         vec[0].elements[N] = TimeValue (t, TimeReference, TimeFormat);
    215         break;
    216       case FWHM:
    217         vec[0].elements[N] = image[j].fwhm_x / 25.0;
    218         break;
    219       case EXPTIME:
    220         vec[0].elements[N] = image[j].exptime;
    221         break;
    222       case NSTAR:
    223         vec[0].elements[N] = image[j].nstar;
    224         break;
    225       case NCAL:
    226         vec[0].elements[N] = image[j].Mxxxx;
    227         break;
    228       case SKY:
    229         vec[0].elements[N] = image[j].Myyyy + 0x8000;
    230         break;
    231       case FLAG:
    232         vec[0].elements[N] = image[j].code;
    233         break;
    234       case NX_PIX:
    235         vec[0].elements[N] = image[j].NX;
    236         break;
    237       case NY_PIX:
    238         vec[0].elements[N] = image[j].NY;
    239         break;
    240       case IMAGE_ID:
    241         vec[0].elements[N] = image[j].imageID;
    242         break;
    243       case THETA: {
    244         double theta1, theta2, s1, s2;
    245         s1 = SIGN(image[j].coords.pc1_1);
    246         s2 = SIGN(image[j].coords.pc2_2);
    247         theta1 = DEG_RAD*atan2 (+s1*image[j].coords.pc1_2, s1*image[j].coords.pc1_1);
    248         theta2 = DEG_RAD*atan2 (-s2*image[j].coords.pc2_1, s2*image[j].coords.pc2_2);
    249         vec[0].elements[N] = 0.5*(theta1+theta2);
    250         break; }
    251       case SKEW: {
    252         double theta1, theta2, s1, s2;
    253         s1 = SIGN(image[j].coords.pc1_1);
    254         s2 = SIGN(image[j].coords.pc2_2);
    255         theta1 = DEG_RAD*atan2 (+s1*image[j].coords.pc1_2, s1*image[j].coords.pc1_1);
    256         theta2 = DEG_RAD*atan2 (-s2*image[j].coords.pc2_1, s2*image[j].coords.pc2_2);
    257         vec[0].elements[N] = (theta1-theta2);
    258         break; }
    259       case SCALE: {
    260         double scale1, scale2;
    261         scale1 = fabs(image[j].coords.cdelt1);
    262         scale2 = fabs(image[j].coords.cdelt2);
    263         vec[0].elements[N] = 0.5*(scale1+scale2);
    264         break; }
    265       case DSCALE: {
    266         double scale1, scale2;
    267         scale1 = fabs(image[j].coords.cdelt1);
    268         scale2 = fabs(image[j].coords.cdelt2);
    269         vec[0].elements[N] = (scale1-scale2);
    270         break; }
    271 
    272     // reference pixel extractions
    273     case X_LL_CHIP:
    274     case Y_LL_CHIP:
    275     case Y_LR_CHIP:
    276     case X_UL_CHIP:
    277       vec[0].elements[N] = 0.0;
    278       break;
    279     case X_LR_CHIP:
    280     case X_UR_CHIP:
    281       vec[0].elements[N] = image[j].NX;
    282       break;
    283     case Y_UL_CHIP:
    284     case Y_UR_CHIP:
    285       vec[0].elements[N] = image[j].NX;
    286       break;
    287 
    288     case X_LL_FP:
    289     case Y_LL_FP:
    290       XY_to_LM (&x, &y, 0.0, 0.0, &image[j].coords);
    291       vec[0].elements[N] = (mode == X_LL_FP) ? x : y;
    292       break;
    293     case X_LR_FP:
    294     case Y_LR_FP:
    295       XY_to_LM (&x, &y, image[j].NX, 0.0, &image[j].coords);
    296       vec[0].elements[N] = (mode == X_LR_FP) ? x : y;
    297       break;
    298     case X_UL_FP:
    299     case Y_UL_FP:
    300       XY_to_LM (&x, &y, 0.0, image[j].NY, &image[j].coords);
    301       vec[0].elements[N] = (mode == X_UL_FP) ? x : y;
    302       break;
    303     case X_UR_FP:
    304     case Y_UR_FP:
    305       XY_to_LM (&x, &y, image[j].NX, image[j].NY, &image[j].coords);
    306       vec[0].elements[N] = (mode == X_UR_FP) ? x : y;
    307       break;
    308     }
    309     N++;
    310   }
    311  
    312   vec[0].Nelements = N;
    313   REALLOCATE (vec[0].elements, float, N);
    314 
    315   free (subset);
    316   free (image);
    317   return (TRUE);
    318  
     230  gprint (GP_ERR, " imextract --help fields : for a complete listing of allowed fields\n");
     231  return (FALSE);
    319232}
    320233 

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

    r14590 r20936  
    1313  char DataBase[256], *Filter;
    1414  double trange;
    15   float *Vec;
     15  opihi_flt *Vec;
    1616  time_t tzero, tend, TimeReference;
    1717  RegImage *image;
    1818  Vector *vec;
    1919
     20  // XXX this function is only valid for the Elixir db system, not the IPP db system
     21  // this function should exit gracefully if the REGISTRATION_DATABASE is missing
    2022  VarConfig ("REGISTRATION_DATABASE", "%s", DataBase);
    2123
    … …  
    132134  N = 0;
    133135  NVEC = 1000;
    134   REALLOCATE (vec[0].elements, float, NVEC);
    135   Vec = vec[0].elements;
     136  ResetVector (vec, OPIHI_FLT, NVEC);
     137  Vec = vec[0].elements.Flt;
    136138
    137139  GetTimeFormat (&TimeReference, &TimeFormat);
    … …  
    216218    if (N >= NVEC - 1) {
    217219      NVEC += 1000;
    218       REALLOCATE (vec[0].elements, float, NVEC);
    219       Vec = vec[0].elements;
    220     }
    221   }
    222 
    223   REALLOCATE (vec[0].elements, float, MAX (1,N));
     220      REALLOCATE (vec[0].elements.Flt, opihi_flt, NVEC);
     221      Vec = vec[0].elements.Flt;
     222    }
     223  }
     224
     225  REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX (1,N));
    224226  vec[0].Nelements = N;
    225227

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

    r13479 r20936  
    3333
    3434  /* assign vector values */
    35   Xvec.Nelements = Nimage;
    36   Yvec.Nelements = Nimage;
    37   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    38   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
     35  SetVector (&Xvec, OPIHI_FLT, Nimage);
     36  SetVector (&Yvec, OPIHI_FLT, Nimage);
     37
    3938  gprint (GP_LOG, "seq  ra (J2000) dec    time (s)   Nstars\n");
    4039  for (i = 0; i < Nimage; i++) {
    41     Xvec.elements[i] = image[i].secz;
     40    Xvec.elements.Flt[i] = image[i].secz;
    4241    if (Mcal)
    43       Yvec.elements[i] = image[i].Mcal;
     42      Yvec.elements.Flt[i] = image[i].Mcal;
    4443    else
    45       Yvec.elements[i] = image[i].dMcal;
     44      Yvec.elements.Flt[i] = image[i].dMcal;
    4645    if (!FindMosaicForImage (image, Nimage, i)) continue;
    4746    XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    4847    gprint (GP_ERR, "%d %8.4f %8.4f %10d %6d  %5.3f %6.3f %6.3f\n",
    49              i, r, d, image[i].tzero, image[i].nstar, Xvec.elements[i],
     48             i, r, d, image[i].tzero, image[i].nstar, Xvec.elements.Flt[i],
    5049             image[i].Mcal, image[i].dMcal);
    5150  }
    … …  
    5453  graphmode.style = 2;
    5554  graphmode.etype = 0;
    56   PlotVectorPair (kapa, Nimage, Xvec.elements, Yvec.elements, &graphmode);
     55  PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    5756 
    58   free (Xvec.elements);
    59   free (Yvec.elements);
     57  free (Xvec.elements.Flt);
     58  free (Yvec.elements.Flt);
    6059  return (TRUE);
    6160}

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

    r16810 r20936  
    102102     catalog.average[N1[i]].R = RA[i] */
    103103
     104  N = 0;
    104105  NPTS = 100;
    105   ALLOCATE (Xvec.elements, float, NPTS);
    106   ALLOCATE (Yvec.elements, float, NPTS);
    107   dYvec.elements = NULL;
    108   if (ErrorBars) { ALLOCATE (dYvec.elements, float, NPTS); }
    109   N = 0;
     106  SetVector (&Xvec, OPIHI_FLT, NPTS);
     107  SetVector (&Yvec, OPIHI_FLT, NPTS);
     108  dYvec.elements.Flt = NULL;
     109  if (ErrorBars) {   
     110    SetVector (&dYvec, OPIHI_FLT, NPTS);
     111  }
    110112
    111113  GetTimeFormat (&TimeReference, &TimeFormat);
    … …  
    124126      m = catalog.average[N1[i]].measureOffset;
    125127      for (j = 0; j < catalog.average[N1[i]].Nmeasure; j++, m++) {
    126         if (ErrorBars) dYvec.elements[N] = catalog.measure[m].dM;
    127         Xvec.elements[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
    128         Yvec.elements[N] = PhotCat (&catalog.measure[m]);
     128        if (ErrorBars) dYvec.elements.Flt[N] = catalog.measure[m].dM;
     129        Xvec.elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
     130        Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m]);
    129131        /**** need to use PhotRel optionally here ****/
    130132        N++;
    131133        if (N == NPTS) {
    132134          NPTS += 100;
    133           REALLOCATE (Xvec.elements, float, NPTS);
    134           REALLOCATE (Yvec.elements, float, NPTS);
    135           if (ErrorBars) { REALLOCATE (dYvec.elements, float, NPTS); }
     135          REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     136          REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
     137          if (ErrorBars) { REALLOCATE (dYvec.elements.Flt, opihi_flt, NPTS); }
    136138        }
    137139      }     
    … …  
    142144 
    143145  if (ErrorBars)
    144     fsortthree (Xvec.elements, Yvec.elements, dYvec.elements, N);
     146    dsortthree (Xvec.elements.Flt, Yvec.elements.Flt, dYvec.elements.Flt, N);
    145147  else
    146     fsortpair (Xvec.elements, Yvec.elements, N);
     148    dsortpair (Xvec.elements.Flt, Yvec.elements.Flt, N);
    147149
    148150  /* autoscale the plot */
    … …  
    154156    graphmode.etype = 0; 
    155157
    156   KapaPrepPlot (kapa, N, &graphmode);
    157   KapaPlotVector (kapa, N, Xvec.elements, "x");
    158   KapaPlotVector (kapa, N, Yvec.elements, "y");
    159158  if (ErrorBars) {
    160     KapaPlotVector (kapa, N, dYvec.elements, "dym");
    161     KapaPlotVector (kapa, N, dYvec.elements, "dyp");
     159    PlotVectorPairErrors (kapa, &Xvec, &Yvec, &dYvec, &graphmode);
     160  } else {
     161    PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    162162  }
    163163
    … …  
    175175
    176176  if (SaveVectors) {
    177     free (xvec[0].elements);
    178     free (yvec[0].elements);
    179     xvec[0].elements = Xvec.elements;
    180     yvec[0].elements = Yvec.elements;
     177    xvec->type = OPIHI_FLT;
     178    yvec->type = OPIHI_FLT;
     179    free (xvec[0].elements.Flt);
     180    free (yvec[0].elements.Flt);
     181    xvec[0].elements.Flt = Xvec.elements.Flt;
     182    yvec[0].elements.Flt = Yvec.elements.Flt;
    181183    xvec[0].Nelements = yvec[0].Nelements = Xvec.Nelements;
    182184  } else {
    183     free (Xvec.elements);
    184     free (Yvec.elements);
     185    free (Xvec.elements.Flt);
     186    free (Yvec.elements.Flt);
    185187  }
    186188
    187   if (ErrorBars) free (dYvec.elements);
     189  if (ErrorBars) free (dYvec.elements.Flt);
    188190  dvo_catalog_free (&catalog);
    189191

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

    r16810 r20936  
    8787  N = 0;
    8888  NPTS = 100;
    89   REALLOCATE (tvec[0].elements, float, NPTS);
    90   REALLOCATE (mvec[0].elements, float, NPTS);
    91   REALLOCATE (dmvec[0].elements, float, NPTS);
     89  ResetVector (tvec, OPIHI_FLT, NPTS);
     90  ResetVector (mvec, OPIHI_FLT, NPTS);
     91  ResetVector (dmvec, OPIHI_FLT, NPTS);
    9292 
    9393  GetTimeFormat (&TimeReference, &TimeFormat);
    … …  
    117117        }     
    118118
    119         tvec[0].elements[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
    120         dmvec[0].elements[N] = catalog.measure[m].dM;
     119        tvec[0].elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
     120        dmvec[0].elements.Flt[N] = catalog.measure[m].dM;
    121121        if (RELPHOT) {
    122           mvec[0].elements[N] = PhotCat (&catalog.measure[m]);
     122          mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m]);
    123123        } else {
    124           mvec[0].elements[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
     124          mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
    125125        }
    126126        N++;
    127127        if (N == NPTS) {
    128128          NPTS += 100;
    129           REALLOCATE (tvec[0].elements, float, NPTS);
    130           REALLOCATE (mvec[0].elements, float, NPTS);
    131           REALLOCATE (dmvec[0].elements, float, NPTS);
     129          REALLOCATE (tvec[0].elements.Flt, opihi_flt, NPTS);
     130          REALLOCATE (mvec[0].elements.Flt, opihi_flt, NPTS);
     131          REALLOCATE (dmvec[0].elements.Flt, opihi_flt, NPTS);
    132132        }
    133133      }     
    134134    }
    135135  }
    136   fsortthree (tvec[0].elements, mvec[0].elements, dmvec[0].elements, N);
     136  dsortthree (tvec[0].elements.Flt, mvec[0].elements.Flt, dmvec[0].elements.Flt, N);
    137137  tvec[0].Nelements = mvec[0].Nelements = dmvec[0].Nelements = N;
    138138

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

    r20819 r20936  
    66  int Nsecfilt, VERBOSE, loadImages, mosaicMode;
    77  char **cstack, name[1024];
    8   float *values;
     8  dbValue *values;
    99  void *Signal;
    1010
    1111  Catalog catalog;
    1212  SkyList *skylist;
    13   PhotCode *code;
    1413  Vector **vec;
    1514  dbField *fields;
    … …  
    1817
    1918  /* defaults */
     19  vec = NULL;
     20  stack = NULL;
     21  fields = NULL;
     22  values = NULL;
    2023  skylist = NULL;
    21   code = NULL;
    22   fields = NULL;
    23   stack = NULL;
     24  selection = NULL;
    2425
    2526  if ((N = get_argument (argc, argv, "-h"))) goto help;
    … …  
    4950  fields = dbCmdlineFields (argc, argv, DVO_TABLE_MEASURE, &last, &Nfields);
    5051  if (fields == NULL) return (FALSE);
     52  if (Nfields == 0) {
     53    FreeSkyRegionSelection (selection);
     54    dbFreeFields (fields, Nfields);
     55    dvo_catalog_free (&catalog);
     56    goto help;
     57  }
    5158
    5259  // examine line for 'where' or 'match to'.  'match to' is forbidden
    … …  
    8895
    8996  /* create storage vector */
    90   ALLOCATE (values, float, Nfields);
     97  Npts = 0;
     98  NPTS = 1000;
     99  ALLOCATE (values, dbValue, Nfields);
    91100  ALLOCATE (vec, Vector *, Nreturn);
    92101  for (i = 0; i < Nreturn; i++) {
    … …  
    97106    }
    98107    if ((vec[i] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) goto escape;
    99   }
    100 
    101   Npts = 0;
    102   NPTS = 1;
     108    ResetVector (vec[i], fields[i].type, NPTS);
     109  }
    103110
    104111  // grab data from all selected sky regions
    … …  
    139146        if (!dbBooleanCond (stack, Nstack, values)) continue;
    140147        for (n = 0; n < Nreturn; n++) {
    141           vec[n][0].elements[Npts] = values[n];
     148          if (vec[n][0].type == OPIHI_FLT) {
     149            vec[n][0].elements.Flt[Npts] = values[n].Flt;
     150          } else {
     151            vec[n][0].elements.Int[Npts] = values[n].Int;
     152          }
    142153          // fprintf (stderr, "keep : field: %s, value: %f\n", fields[n].name, values[n]);
    143154        }
    … …  
    146157          NPTS += 2000;
    147158          for (n = 0; n < Nreturn; n++) {
    148             REALLOCATE (vec[n][0].elements, float, NPTS);
     159            REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
    149160          }
    150161        }
    … …  
    161172
    162173  for (n = 0; n < Nreturn; n++) {
    163     vec[n][0].Nelements = Npts;
    164     REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
    165   }
    166 
     174    ResetVector (vec[n], fields[n].type, MAX(1,Npts));
     175  }
     176
     177  if (vec) free (vec);
     178  if (values) free (values);
    167179  dbFreeFields (fields, Nfields);
    168180  dbFreeStack (stack, Nstack);
    … …  
    174186
    175187escape:
     188  if (vec) free (vec);
     189  free (values);
    176190  dbFreeFields (fields, Nfields);
    177191  dbFreeStack (stack, Nstack);

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

    r20819 r20936  
    88  int Nsecfilt, VERBOSE, loadImages, mosaicMode;
    99  char **cstack1, **cstack2, name1[1024], name2[1024];
    10   float *values, **table1, **table2;
     10  dbValue *values, **table1, **table2;
    1111  void *Signal;
    1212
    1313  Catalog catalog;
    1414  SkyList *skylist;
    15   PhotCode *code;
    1615  Vector **vec;
    1716  dbField *fields;
    … …  
    2120
    2221  /* defaults */
    23   skylist = NULL;
    24   code = NULL;
    25   fields = NULL;
     22  vec = NULL;
    2623  stack1 = NULL;
    2724  stack2 = NULL;
     25  fields = NULL;
     26  values = NULL;
     27  skylist = NULL;
     28  selection = NULL;
    2829
    2930  if ((N = get_argument (argc, argv, "-h"))) goto help;
    … …  
    5758  // parse the fields to be extracted and returned : last points to end, or first 'where' or 'matched'
    5859  fields = dbCmdlineFields (argc, argv, DVO_TABLE_MEASURE, &last, &Nfields);
    59   if (fields == NULL) return (FALSE);
     60  if (fields == NULL) goto escape;
     61  if (Nfields == 0) {
     62    FreeSkyRegionSelection (selection);
     63    dbFreeFields (fields, Nfields);
     64    dvo_catalog_free (&catalog);
     65    goto help;
     66  }
    6067
    6168  // examine line for 'where' and 'match to'.  neither is required, but order is fixed
    … …  
    139146
    140147  /* create storage vector */
    141   ALLOCATE (values, float, Nfields);
     148  ALLOCATE (values, dbValue, Nfields);
    142149  ALLOCATE (vec, Vector *, Nreturn);
    143150
    … …  
    152159    if ((vec[2*i+0] = SelectVector (name1, ANYVECTOR, TRUE)) == NULL) goto escape;
    153160    if ((vec[2*i+1] = SelectVector (name2, ANYVECTOR, TRUE)) == NULL) goto escape;
     161    ResetVector (vec[2*i+0], fields[i].type, fields[i].type);
     162    ResetVector (vec[2*i+1], fields[i].type, fields[i].type);
    154163  }
    155164
    … …  
    158167
    159168  // we save the selected measures for each average to temporary tables 1 and 2
     169  // XXX need to deal with the INT / DBL difference here...
    160170  NTABLE = 100;
    161   ALLOCATE (table1, float *, Nreturn_base);
    162   ALLOCATE (table2, float *, Nreturn_base);
     171  ALLOCATE (table1, dbValue *, Nreturn_base);
     172  ALLOCATE (table2, dbValue *, Nreturn_base);
    163173  for (i = 0; i < Nreturn_base; i++) {
    164     ALLOCATE (table1[i], float, NTABLE);
    165     ALLOCATE (table2[i], float, NTABLE);
     174    ALLOCATE (table1[i], dbValue, NTABLE);
     175    ALLOCATE (table2[i], dbValue, NTABLE);
    166176  }
    167177
    … …  
    194204        NTABLE = catalog.average[j].Nmeasure;
    195205        for (n = 0; n < Nreturn_base; n++) {
    196           REALLOCATE (table1[n], float, NTABLE);
    197           REALLOCATE (table2[n], float, NTABLE);
     206          REALLOCATE (table1[n], dbValue, NTABLE);
     207          REALLOCATE (table2[n], dbValue, NTABLE);
    198208        }
    199209      }
    … …  
    206216        dbExtractMeasuresInitMeas (); // reset counters for saved fields
    207217        for (n = 0; n < Nfields; n++) {
     218          // values needs to be a pointer to a type with FLT and INT (with a union, we would save a bit of memory...)
    208219          values[n] = dbExtractMeasures (&catalog.average[j], &catalog.secfilt[j*Nsecfilt], &catalog.measure[m], &fields[n]);
    209220        }
    … …  
    232243        for (n2 = 0; n2 < Nt2; n2++) {
    233244          for (n = 0; n < Nreturn_base; n++) {
    234             vec[2*n+0][0].elements[Npts] = table1[n][n1];
    235             vec[2*n+1][0].elements[Npts] = table2[n][n2];
     245            if (vec[2*n+0][0].type == OPIHI_FLT) {
     246              vec[2*n+0][0].elements.Flt[Npts] = table1[n][n1].Flt;
     247              vec[2*n+1][0].elements.Flt[Npts] = table2[n][n2].Flt;
     248            } else {
     249              vec[2*n+0][0].elements.Int[Npts] = table1[n][n1].Int;
     250              vec[2*n+1][0].elements.Int[Npts] = table2[n][n2].Int;
     251            }
    236252          }
    237253          Npts++;
    … …  
    239255            NPTS += 2000;
    240256            for (n = 0; n < Nreturn; n++) {
    241               REALLOCATE (vec[n][0].elements, float, NPTS);
     257              if (vec[n][0].type == OPIHI_FLT) {
     258                REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
     259              } else {
     260                REALLOCATE (vec[n][0].elements.Int, opihi_int, NPTS);
     261              }
    242262            }
    243263          }
    … …  
    255275  interrupt = FALSE;
    256276
     277  // free excess memory
    257278  for (n = 0; n < Nreturn; n++) {
    258279    vec[n][0].Nelements = Npts;
    259     REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
     280    if (vec[n][0].type == OPIHI_FLT) {
     281      REALLOCATE (vec[n][0].elements.Flt, opihi_flt, MAX(1,Npts));
     282    } else {
     283      REALLOCATE (vec[n][0].elements.Int, opihi_int, MAX(1,Npts));
     284    }
    260285  }
    261286
    … …  
    280305
    281306escape:
     307  if (vec) free (vec);
     308  if (values) free (values);
    282309  dbFreeFields (fields, Nfields);
    283310  dbFreeStack (stack1, Nstack1);
    … …  
    292319
    293320 help:
    294   gprint (GP_ERR, "USAGE: mextract field[,field,field...] where (expression)\n");
     321  gprint (GP_ERR, "USAGE: mmextract field[,field,field...] where (expression) match to (expression)\n");
     322  gprint (GP_ERR, "  pairs of fields are returned: the first set are restricted by the 'where' expression, the second by the 'match to' expression\n");
    295323
    296324  if ((argc > N + 1) && !strcasecmp (argv[N+1], "fields")) {
    … …  
    344372    return (FALSE);
    345373  }
    346   gprint (GP_ERR, " mextract --help fields : for a complete listing of allowed fields\n");
     374  gprint (GP_ERR, " mmextract --help fields : for a complete listing of allowed fields\n");
    347375  return (FALSE);
    348376}

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

    r20535 r20936  
    3838    photcode = GetPhotcodebyName (argv[Narg]);
    3939    if (!photcode) {
    40         fprintf (stderr, "unknown photcode %s\n", argv[Narg]);
    41         return (FALSE);
     40      fprintf (stderr, "unknown photcode %s\n", argv[Narg]);
     41      return (FALSE);
    4242    }
    4343    remove_argument (Narg, &argc, argv);
    4444    Nsec = GetPhotcodeNsec (photcode[0].code);
    4545    if (Nsec == -1) {
    46         fprintf (stderr, "photcode %s is not an AVERAGE photcode\n", argv[Narg]);
    47         return (FALSE);
     46      fprintf (stderr, "photcode %s is not an AVERAGE photcode\n", argv[Narg]);
     47      return (FALSE);
    4848    }
    4949  }
    … …  
    138138
    139139      if (Npts == NPTS - 1) {
    140           NPTS += 1000;
    141           REALLOCATE (Xvec, float, NPTS);
    142           REALLOCATE (Yvec, float, NPTS);
    143           REALLOCATE (Zvec, float, NPTS);
     140        NPTS += 1000;
     141        REALLOCATE (Xvec, float, NPTS);
     142        REALLOCATE (Yvec, float, NPTS);
     143        REALLOCATE (Zvec, float, NPTS);
    144144      }
    145145      if ((Npts > NCHUNK) || (Nloaded >= 25)) {
    146           PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
    147           Npts = 0;
    148           Nloaded = 0;
     146        KapaPrepPlot (kapa, Npts, &graphmode);
     147        KapaPlotVector (kapa, Npts, Xvec, "x");
     148        KapaPlotVector (kapa, Npts, Yvec, "y");
     149        KapaPlotVector (kapa, Npts, Zvec, "z");
     150        Npts = 0;
     151        Nloaded = 0;
    149152      }
    150153    }
    … …  
    152155    dvo_catalog_free (&catalog);
    153156  }
    154   if (Npts > 0) PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
     157  if (Npts > 0) {
     158    KapaPrepPlot (kapa, Npts, &graphmode);
     159    KapaPlotVector (kapa, Npts, Xvec, "x");
     160    KapaPlotVector (kapa, Npts, Yvec, "y");
     161    KapaPlotVector (kapa, Npts, Zvec, "z");
     162  }
    155163
    156164  free (Xvec);

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

    r20535 r20936  
    223223
    224224        if (Npts == NPTS - 1) {
    225             NPTS += 1000;
    226             REALLOCATE (Xvec, float, NPTS);
    227             REALLOCATE (Yvec, float, NPTS);
    228             REALLOCATE (Zvec, float, NPTS);
     225          NPTS += 1000;
     226          REALLOCATE (Xvec, float, NPTS);
     227          REALLOCATE (Yvec, float, NPTS);
     228          REALLOCATE (Zvec, float, NPTS);
    229229        }
    230230        if ((Npts > NCHUNK) || (Nloaded >= 25)) {
    231             PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
    232             Npts = 0;
    233             Nloaded = 0;
     231          KapaPrepPlot (kapa, Npts, &graphmode);
     232          KapaPlotVector (kapa, Npts, Xvec, "x");
     233          KapaPlotVector (kapa, Npts, Yvec, "y");
     234          KapaPlotVector (kapa, Npts, Zvec, "z");
     235          Npts = 0;
     236          Nloaded = 0;
    234237        }
    235238      }
    … …  
    238241    dvo_catalog_free (&catalog);
    239242  }
    240   if (Npts > 0) PlotVectorTriplet (kapa, Npts, Xvec, Yvec, Zvec, &graphmode);
    241 
     243  if (Npts > 0) {
     244    KapaPrepPlot (kapa, Npts, &graphmode);
     245    KapaPlotVector (kapa, Npts, Xvec, "x");
     246    KapaPlotVector (kapa, Npts, Yvec, "y");
     247    KapaPlotVector (kapa, Npts, Zvec, "z");
     248  }
    242249  free (Xvec);
    243250  free (Yvec);

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

    r19823 r20936  
    9595
    9696  /* data has been loaded, get ready to plot it */
    97   Yvec.Nelements = Xvec.Nelements = 3*Nrocks;
    98   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    99   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
     97  SetVector (&Xvec, OPIHI_FLT, 3*Nrocks);
     98  SetVector (&Yvec, OPIHI_FLT, 3*Nrocks);
    10099 
    101100  /* project stars to screen display coords */
    … …  
    106105      while (rocks[i].ra[j] < Rmin) rocks[i].ra[j] += 360.0;
    107106      while (rocks[i].ra[j] > Rmax) rocks[i].ra[j] -= 360.0;
    108       fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], rocks[i].ra[j], rocks[i].dec[j], &graphmode.coords);
     107      RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], rocks[i].ra[j], rocks[i].dec[j], &graphmode.coords);
    109108      N ++;
    110109    }
    … …  
    114113  graphmode.style = 2; /* set style to points */
    115114  graphmode.etype = 0; /* no errorbars */
    116   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     115  PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    117116
    118117  /* now plot vectors between two extrema */
    119118  Yvec.Nelements = Xvec.Nelements = 2*Nrocks;
    120   REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    121   REALLOCATE (Yvec.elements, float, Yvec.Nelements);
     119  REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     120  REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    122121 
    123122  /* project stars to screen display coords */
    … …  
    136135    while (rocks[i].ra[N1] < Rmin) rocks[i].ra[N1] += 360.0;
    137136    while (rocks[i].ra[N1] > Rmax) rocks[i].ra[N1] -= 360.0;
    138     fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], rocks[i].ra[N0], rocks[i].dec[N0], &graphmode.coords);
     137    RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], rocks[i].ra[N0], rocks[i].dec[N0], &graphmode.coords);
    139138    N ++;
    140     fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], rocks[i].ra[N1], rocks[i].dec[N1], &graphmode.coords);
     139    RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], rocks[i].ra[N1], rocks[i].dec[N1], &graphmode.coords);
    141140    N ++;
    142141  }
    … …  
    147146  graphmode.etype = 0; /* no errorbars */
    148147
    149   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     148  PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    150149
    151   free (Xvec.elements);
    152   free (Yvec.elements);
     150  free (Xvec.elements.Flt);
     151  free (Yvec.elements.Flt);
    153152  return (TRUE);
    154153

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

    r13479 r20936  
    2222  N = 0;
    2323  NPTS = 200;
    24   ALLOCATE (Xvec.elements, float, NPTS);
    25   ALLOCATE (Yvec.elements, float, NPTS);
     24  SetVector (&Xvec, OPIHI_FLT, NPTS);
     25  SetVector (&Yvec, OPIHI_FLT, NPTS);
    2626
    2727  /* starting position */
    … …  
    4949      for (i = 0; i < 4; i++) {
    5050        fXY_to_RD (&R, &D, dr[i], dd[i], &coords);
    51         status |= fRD_to_XY (&Xvec.elements[N+2*i], &Yvec.elements[N+2*i], R, D, &graphmode.coords);
     51        status |= RD_to_XY (&Xvec.elements.Flt[N+2*i], &Yvec.elements.Flt[N+2*i], R, D, &graphmode.coords);
    5252        if (i > 0) {
    53           Xvec.elements[N+2*i - 1] = Xvec.elements[N+2*i];
    54           Yvec.elements[N+2*i - 1] = Yvec.elements[N+2*i];
     53          Xvec.elements.Flt[N+2*i - 1] = Xvec.elements.Flt[N+2*i];
     54          Yvec.elements.Flt[N+2*i - 1] = Yvec.elements.Flt[N+2*i];
    5555        }
    5656        if (i == 1) {
    … …  
    5959        }
    6060      }
    61       Xvec.elements[N+7] = Xvec.elements[N];
    62       Yvec.elements[N+7] = Yvec.elements[N];
     61      Xvec.elements.Flt[N+7] = Xvec.elements.Flt[N];
     62      Yvec.elements.Flt[N+7] = Yvec.elements.Flt[N];
    6363
    6464      /* check if any corner is in plotting region */
    6565      InPic = FALSE;
    6666      for (i = 0; i < 8; i+=2) {
    67         if ((Xvec.elements[N+i] >= graphmode.xmin) &&
    68             (Xvec.elements[N+i] <= graphmode.xmax) &&
    69             (Yvec.elements[N+i] >= graphmode.ymin) &&
    70             (Yvec.elements[N+i] <= graphmode.ymax))
     67        if ((Xvec.elements.Flt[N+i] >= graphmode.xmin) &&
     68            (Xvec.elements.Flt[N+i] <= graphmode.xmax) &&
     69            (Yvec.elements.Flt[N+i] >= graphmode.ymin) &&
     70            (Yvec.elements.Flt[N+i] <= graphmode.ymax))
    7171          InPic = TRUE;
    7272      }
    … …  
    7575      if (N > NPTS - 1) {  /* this is OK because NPTS is made always a multiple of 8 */
    7676        NPTS += 200;
    77         REALLOCATE (Xvec.elements, float, NPTS);
    78         REALLOCATE (Yvec.elements, float, NPTS);
     77        REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     78        REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    7979      }
    8080    }
    8181  }
    8282 
    83   Xvec.Nelements = Xvec.Nelements = N;
     83  Xvec.Nelements = Yvec.Nelements = N;
    8484  if (N > 0) {
    8585    graphmode.style = 2; /* points */
    8686    graphmode.ptype = 100; /* connect pairs of points */
    8787    graphmode.etype = 0;
    88     PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     88    PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    8989  }
    9090
    91   free (Xvec.elements);
    92   free (Yvec.elements);
     91  free (Xvec.elements.Flt);
     92  free (Yvec.elements.Flt);
    9393  return (TRUE);
    9494

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

    r13479 r20936  
    9292
    9393  /* set up storage buffers */
    94   Xvec.Nelements = Nstars;
    95   Yvec.Nelements = Nstars;
    96   Zvec.Nelements = Nstars;
    97   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    98   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
    99   ALLOCATE (Zvec.elements, float, Zvec.Nelements);
     94  SetVector (&Xvec, OPIHI_FLT, Nstars);
     95  SetVector (&Yvec, OPIHI_FLT, Nstars);
     96  SetVector (&Zvec, OPIHI_FLT, Nstars);
    10097  ALLOCATE (buffer, char, (BLOCK*BYTES_STAR));
    10198
    … …  
    107104    if (nbytes != BLOCK*BYTES_STAR) {
    108105      gprint (GP_ERR, "failed to read in stars (1)\n");
    109       free (Xvec.elements);
    110       free (Yvec.elements);
    111       free (Zvec.elements);
     106      free (Xvec.elements.Flt);
     107      free (Yvec.elements.Flt);
     108      free (Zvec.elements.Flt);
    112109      free (buffer);
    113110      return (FALSE);
    … …  
    118115      dparse (&M,  3, &buffer[j*BYTES_STAR]);
    119116      XY_to_RD (&R, &D, X, Y, &coords);
    120       fRD_to_XY (&Xvec.elements[nstars], &Yvec.elements[nstars], R, D, &graphmode.coords);
    121       Zvec.elements[nstars] = MIN (1.0, MAX (0.01, (M - zero) / range));
     117      RD_to_XY (&Xvec.elements.Flt[nstars], &Yvec.elements.Flt[nstars], R, D, &graphmode.coords);
     118      Zvec.elements.Flt[nstars] = MIN (1.0, MAX (0.01, (M - zero) / range));
    122119    }
    123120  }
    … …  
    126123  if (nbytes != (Nbytes % (BLOCK*BYTES_STAR))) {
    127124    gprint (GP_ERR, "ERROR: failed to read in stars (2)\n");
    128     free (Xvec.elements);
    129     free (Yvec.elements);
    130     free (Zvec.elements);
     125    free (Xvec.elements.Flt);
     126    free (Yvec.elements.Flt);
     127    free (Zvec.elements.Flt);
    131128    free (buffer);
    132129    return (FALSE);
    … …  
    137134    dparse (&M,  3, &buffer[j*BYTES_STAR]);
    138135    XY_to_RD (&R, &D, X, Y, &coords);
    139     fRD_to_XY (&Xvec.elements[nstars], &Yvec.elements[nstars], R, D, &graphmode.coords);
    140     Zvec.elements[nstars] = MIN (1.0, MAX (0.01, (M - zero) / range));
     136    RD_to_XY (&Xvec.elements.Flt[nstars], &Yvec.elements.Flt[nstars], R, D, &graphmode.coords);
     137    Zvec.elements.Flt[nstars] = MIN (1.0, MAX (0.01, (M - zero) / range));
    141138  }
    142139 
    143140  if (nstars != Nstars) {
    144141    gprint (GP_ERR, "ERROR: failed to read in all stars (%d of %d)\n", nstars, Nstars);
    145     free (Xvec.elements);
    146     free (Yvec.elements);
    147     free (Zvec.elements);
     142    free (Xvec.elements.Flt);
     143    free (Yvec.elements.Flt);
     144    free (Zvec.elements.Flt);
    148145    free (buffer);
    149146    return (FALSE);
    … …  
    155152  Npts = Xvec.Nelements;
    156153
    157   PlotVectorTriplet (kapa, Npts, Xvec.elements, Yvec.elements, Zvec.elements, &graphmode);
     154  PlotVectorTriplet (kapa, &Xvec, &Yvec, &Zvec, &graphmode);
    158155
    159   free (Xvec.elements);
    160   free (Yvec.elements);
    161   free (Zvec.elements);
     156  free (Xvec.elements.Flt);
     157  free (Yvec.elements.Flt);
     158  free (Zvec.elements.Flt);
    162159  free (buffer);
    163160

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

    r20535 r20936  
    5353  Rmid = 0.5*(Rmin + Rmax);
    5454
     55  Npts = 0;
    5556  NPTS = 200;
    56   ALLOCATE (Xvec.elements, float, NPTS);
    57   ALLOCATE (Yvec.elements, float, NPTS);
    58   Npts = 0;
     57  SetVector (&Xvec, OPIHI_FLT, NPTS);
     58  SetVector (&Yvec, OPIHI_FLT, NPTS);
    5959   
    6060  regions = skylist[0].regions;
    … …  
    7676      RD_to_XYpic (&X[3], &Y[3], regions[i][0].Rmax, regions[i][0].Dmin, &graphmode.coords, Rmin, Rmax, Rmid, &leftside);
    7777
    78       Xvec.elements[Npts] = X[0];
    79       Yvec.elements[Npts] = Y[0];
     78      Xvec.elements.Flt[Npts] = X[0];
     79      Yvec.elements.Flt[Npts] = Y[0];
    8080      for (j = 1; j < 4; j++) {
    81         Xvec.elements[Npts + j*2 - 0] = X[j];
    82         Yvec.elements[Npts + j*2 - 0] = Y[j];
    83         Xvec.elements[Npts + j*2 - 1] = X[j];
    84         Yvec.elements[Npts + j*2 - 1] = Y[j];
     81        Xvec.elements.Flt[Npts + j*2 - 0] = X[j];
     82        Yvec.elements.Flt[Npts + j*2 - 0] = Y[j];
     83        Xvec.elements.Flt[Npts + j*2 - 1] = X[j];
     84        Yvec.elements.Flt[Npts + j*2 - 1] = Y[j];
    8585      }
    86       Xvec.elements[Npts+7] = Xvec.elements[Npts];
    87       Yvec.elements[Npts+7] = Yvec.elements[Npts];
     86      Xvec.elements.Flt[Npts+7] = Xvec.elements.Flt[Npts];
     87      Yvec.elements.Flt[Npts+7] = Yvec.elements.Flt[Npts];
    8888      Npts += 8;
    8989      if (Npts > NPTS - 1) {  /* this is OK because NPTS is made always a multiple of 8 */
    9090        NPTS += 200;
    91         REALLOCATE (Xvec.elements, float, NPTS);
    92         REALLOCATE (Yvec.elements, float, NPTS);
     91        REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     92        REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    9393      }
    9494    }
    … …  
    9696
    9797  gprint (GP_ERR, "plotting %d catalogs\n", Npts/8);
    98   Xvec.Nelements = Xvec.Nelements = Npts;
     98  Xvec.Nelements = Yvec.Nelements = Npts;
    9999  if (Npts > 0) {
    100100    graphmode.style = 2; /* points */
    101101    graphmode.ptype = 100; /* connect pairs of points */
    102102    graphmode.etype = 0;
    103     PlotVectorPair (kapa, Npts, Xvec.elements, Yvec.elements, &graphmode);
     103    PlotVectorPair (kapa, &Xvec, &Yvec, &graphmode);
    104104  }
    105105
    106   free (Xvec.elements);
    107   free (Yvec.elements);
     106  free (Xvec.elements.Ptr);
     107  free (Yvec.elements.Ptr);
    108108  free (regions);
    109109

  • trunk/Ohana/src/opihi/include/data.h

    r17419 r20936  
    7878void fft1D (float *dataRe, float *dataIm, int N, int Nbit, int forward);
    7979int fftND (float *dataRe, float *dataIm, int Ndim, int *Nsize, int forward);
     80void dfft1D (double *dataRe, double *dataIm, int N, int Nbit, int forward);
     81int dfftND (double *dataRe, double *dataIm, int Ndim, int *Nsize, int forward);
    8082int IsBinary (int N, int *Nbit);
    8183
    … …  
    8587
    8688/* in svdcmp.c */
    87 int svdcmp (float *a, float *w, float *v, int Nx, int Ny);
     89int svdcmp (float *a, opihi_flt *w, float *v, int Nx, int Ny);
    8890
    8991/* mrqmin.c */
    90 float mrqcof (float *x, float *y, float *dy, int Npts,
    91               float *par, int Npar, float **ta, float **tb,
    92               float (funcs)(float, float *, int, float *));
     92opihi_flt mrqcof (opihi_flt *x, opihi_flt *y, opihi_flt *dy, int Npts,
     93              opihi_flt *par, int Npar, opihi_flt **ta, opihi_flt **tb,
     94              opihi_flt (funcs)(opihi_flt, opihi_flt *, int, opihi_flt *));
    9395
    94 float mrqmin (float *x, float *y, float *dy, int Npts,
    95               float *par, int Npar,
    96               float (funcs)(float, float *, int, float *), int VERBOSE);
     96opihi_flt mrqmin (opihi_flt *x, opihi_flt *y, opihi_flt *dy, int Npts,
     97              opihi_flt *par, int Npar,
     98              opihi_flt (funcs)(opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE);
    9799
    98 float mrqinit (float *x, float *y, float *dy, int Npts,
    99                float *par, int Npar,
    100                float (funcs)(float, float *, int, float *), int VERBOSE);
     100opihi_flt mrqinit (opihi_flt *x, opihi_flt *y, opihi_flt *dy, int Npts,
     101               opihi_flt *par, int Npar,
     102               opihi_flt (funcs)(opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE);
    101103
    102 float **mrqcovar (int Npar);
     104opihi_flt **mrqcovar (int Npar);
    103105
    104106void mrqfree (int Npar);
    105107
    106108/* mrq2dmin.c */
    107 float mrq2dcof (float *x, float *t, float *y, float *dy, int Npts,
    108                 float *par, int Npar, float **ta, float **tb,
    109                 float (funcs)(float, float, float *, int, float *));
     109opihi_flt mrq2dcof (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     110                opihi_flt *par, int Npar, opihi_flt **ta, opihi_flt **tb,
     111                opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *));
    110112
    111 float mrq2dmin (float *x, float *t, float *y, float *dy, int Npts,
    112                 float *par, int Npar,
    113                 float (funcs)(float, float, float *, int, float *), int VERBOSE);
     113opihi_flt mrq2dmin (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     114                opihi_flt *par, int Npar,
     115                opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE);
    114116
    115 float mrq2dinit (float *x, float *t, float *y, float *dy, int Npts,
    116                  float *par, int Npar,
    117                  float (funcs)(float, float, float *, int, float *), int VERBOSE);
     117opihi_flt mrq2dinit (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     118                 opihi_flt *par, int Npar,
     119                 opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE);
    118120
    119 float mrq2dchi (float *x, float *t, float *y, float *dy, int Npts,
    120                 float *par, int Npar,
    121                 float (funcs)(float, float, float *, int, float *));
     121opihi_flt mrq2dchi (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     122                opihi_flt *par, int Npar,
     123                opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *));
    122124
    123 int mrq2dlimits (float *pmin, float *pmax, int Npar);
     125int mrq2dlimits (opihi_flt *pmin, opihi_flt *pmax, int Npar);
    124126
    125 float **mrq2dcovar (int Npar);
     127opihi_flt **mrq2dcovar (int Npar);
    126128
    127129void mrq2dfree (int Npar);
    … …  
    135137double get_aperture_stats (Matrix *matrix, int X, int Y, int Npix, int Nborder, double max);
    136138int set_rough_radii (double Ra, double Ri, double Ro);
    137 int get_rough_star (float *data, int Nx, int Ny, int x, int y, float *xc, float *yc, float *sx, float *sy, float *sxy, float *zs, float *zp, float *sk);
     139int get_rough_star (float *data, int Nx, int Ny, int x, int y, opihi_flt *xc, opihi_flt *yc, opihi_flt *sx, opihi_flt *sy, opihi_flt *sxy, opihi_flt *zs, opihi_flt *zp, opihi_flt *sk);
    138140
    139141/* precess.c */

  • trunk/Ohana/src/opihi/include/display.h

    r13479 r20936  
    11# include "external.h"
    22# include "kapa.h"
     3# include "dvomath.h"
    34
    45# ifndef DISPLAY_H
    … …  
    67
    78/*** kapa graph functions ***/
    8 int           PlotVectorPair        PROTO((int kapa, int Npts, float *xValues, float *yValues, Graphdata *graphmode));
    9 int           PlotVectorTriplet     PROTO((int kapa, int Npts, float *xValues, float *yValues, float *zValues, Graphdata *graphmode));
     9int           PlotVectorSingle      PROTO((int kapa, Vector *vec, char *mode));
     10int           PlotVectorPair        PROTO((int kapa, Vector *xVec, Vector *yVec, Graphdata *graphmode));
     11int           PlotVectorPairErrors  PROTO((int kapa, Vector *xVec, Vector *yVec, Vector *dyValues, Graphdata *graphmode));
     12int           PlotVectorTriplet     PROTO((int kapa, Vector *xVec, Vector *yVec, Vector *zValues, Graphdata *graphmode));
    1013int           GetGraphData          PROTO((Graphdata *data, int *kapa, char *name));
    1114int           GetGraph              PROTO((Graphdata *data, int *kapa, char *name));

  • trunk/Ohana/src/opihi/include/dvomath.h

    r15878 r20936  
    44# define DVOMATH_H
    55
     6# define OPIHI_NAME_SIZE 1024
     7
    68# define NCHARS 256
     9# define opihi_flt double
     10# define opihi_int int
     11// NOTE: if opihi_int is changed to unsigned, all subtraction and negation operations
     12// need to result in a float value (or 3 - 5 will yield the unexpected value 2^32 - 2)
     13
     14# define REQUIRE_VECTOR_FLT(VECT,RVAL) { \
     15  if (VECT->type != OPIHI_FLT) { \
     16    gprint (GP_ERR, "function requires vector of type FLT\n"); \
     17    return (RVAL); \
     18  } }
     19
     20# define REQUIRE_VECTOR_INT(VECT,RVAL) {        \
     21  if (VECT->type != OPIHI_INT) { \
     22    gprint (GP_ERR, "function requires vector of type INT\n"); \
     23    return (RVAL); \
     24  } }
    725
    826enum {ANYVECTOR, NEWVECTOR, OLDVECTOR};
    927enum {ANYBUFFER, NEWBUFFER, OLDBUFFER};
     28enum {OPIHI_FLT, OPIHI_INT};
    1029
    1130typedef struct {                        /* representation of a variable (0-D) */
    … …  
    1534
    1635typedef struct {                        /* representation of a vector (1-D) */
    17   char name[1024];
    18   float *elements;
     36  char name[OPIHI_NAME_SIZE];
     37  char type;
     38  union {
     39    void      *Ptr;
     40    opihi_flt *Flt;
     41    opihi_int *Int;
     42  } elements;
    1943  int Nelements;
    2044} Vector;
    2145
    2246typedef struct {                        /* representation of buffer (image) */
    23   char name[1024];
    24   char file[1024];
     47  char name[OPIHI_NAME_SIZE];
     48  char file[OPIHI_NAME_SIZE];
    2549  Header header;
    2650  Matrix matrix;
    … …  
    3256  char   *name;
    3357  char    type;
    34   float  *ptr;
    3558  Buffer *buffer;
    3659  Vector *vector;
    37   float   Float;
     60  opihi_flt FltValue;
     61  opihi_int IntValue;
    3862} StackVar;
    3963
    … …  
    87111void          InitVectors           PROTO((void));
    88112int           CopyVector            PROTO((Vector *out, Vector *in));
     113int           ResetVector           PROTO((Vector *vec, char type, int Nelements));
     114int           SetVector             PROTO((Vector *vec, char type, int Nelements));
     115int           CastVector            PROTO((Vector *vec, char type));
     116int           MatchVector           PROTO((Vector *out, Vector *in, char type));
    89117int           MoveVector            PROTO((Vector *out, Vector *in));
    90118int           DeleteVector          PROTO((Vector *vec));

  • trunk/Ohana/src/opihi/include/dvoshell.h

    r19579 r20936  
    55# ifndef DVOSHELL_H
    66# define DVOSHELL_H
     7
     8typedef enum {
     9  DB_STACK_NONE  = 0,
     10  DB_STACK_INT   = 0x01,
     11  DB_STACK_FIELD = 0x02,
     12  DB_STACK_TEMP  = 0x04,
     13  DB_STACK_VALUE = 0x08,
     14  DB_STACK_CLOSE_PAR = 0x10,
     15  DB_STACK_OPEN_PAR,
     16  DB_STACK_LOGIC,
     17  DB_STACK_COMPARE,
     18  DB_STACK_BITWISE,
     19  DB_STACK_SUM,
     20  DB_STACK_MULTIPLY,
     21  DB_STACK_POWER,
     22  DB_STACK_UNARY,
     23} dbStackTypes;
    724
    825/* magnitude types */
    … …  
    7491      MEAS_XCCD,
    7592      MEAS_YCCD,
     93      MEAS_XCCD_ERR,
     94      MEAS_YCCD_ERR,
    7695      MEAS_XMOSAIC,
    7796      MEAS_YMOSAIC,
    … …  
    115134      AVE_TYPE,
    116135      AVE_TYPEFRAC,
    117       AVE_OBJID
     136      AVE_OBJID,
     137      AVE_CATID
    118138};
    119139
    120 enum {DVO_TABLE_AVERAGE, DVO_TABLE_MEASURE};
     140enum {IMAGE_ZERO,
     141      IMAGE_RA,
     142      IMAGE_DEC,
     143      IMAGE_GLON,
     144      IMAGE_GLAT,
     145      IMAGE_ELON,
     146      IMAGE_ELAT,
     147      IMAGE_XM,
     148      IMAGE_AIRMASS,
     149      IMAGE_MCAL,
     150      IMAGE_dMCAL,
     151      IMAGE_PHOTCODE,
     152      IMAGE_TIME,
     153      IMAGE_FWHM,
     154      IMAGE_EXPTIME,
     155      IMAGE_NSTAR,
     156      IMAGE_NCAL,
     157      IMAGE_SKY,
     158      IMAGE_FLAG,
     159      IMAGE_CCDNUM,
     160      IMAGE_NX_PIX,
     161      IMAGE_NY_PIX,
     162      IMAGE_THETA,
     163      IMAGE_SKEW,
     164      IMAGE_SCALE,
     165      IMAGE_DSCALE,
     166      IMAGE_APRESID,
     167      IMAGE_DAPRESID,
     168      IMAGE_SIDTIME,
     169      IMAGE_LATITUDE,
     170      IMAGE_DET_LIMIT,
     171      IMAGE_SAT_LIMIT,
     172      IMAGE_CERROR,
     173      IMAGE_FWHM_MAJ,
     174      IMAGE_FWHM_MIN,
     175      IMAGE_TRATE,
     176      IMAGE_IMAGE_ID,
     177      IMAGE_EXTERN_ID,
     178      IMAGE_SOURCE_ID,
     179      IMAGE_X_LL_CHIP,
     180      IMAGE_X_LR_CHIP,
     181      IMAGE_X_UL_CHIP,
     182      IMAGE_X_UR_CHIP,
     183      IMAGE_Y_LL_CHIP,
     184      IMAGE_Y_LR_CHIP,
     185      IMAGE_Y_UL_CHIP,
     186      IMAGE_Y_UR_CHIP,
     187      IMAGE_X_LL_FP,
     188      IMAGE_X_LR_FP,
     189      IMAGE_X_UL_FP,
     190      IMAGE_X_UR_FP,
     191      IMAGE_Y_LL_FP,
     192      IMAGE_Y_LR_FP,
     193      IMAGE_Y_UL_FP,
     194      IMAGE_Y_UR_FP,
     195};
     196
     197
     198enum {DVO_TABLE_AVERAGE, DVO_TABLE_MEASURE, DVO_TABLE_IMAGE};
    121199enum {DVO_DB_CMDLINE_ERROR, DVO_DB_CMDLINE_IS_END, DVO_DB_CMDLINE_IS_WHERE, DVO_DB_CMDLINE_IS_MATCH};
    122200
    … …  
    136214  int ID;
    137215  int magMode;
     216  char type;
    138217  PhotCode *photcode;
    139218} dbField;
    … …  
    144223  char    type;
    145224  int     field;
    146   float   Float;
     225  opihi_flt FltValue;
     226  opihi_int IntValue;
    147227} dbStack;
     228
     229typedef struct {
     230  opihi_flt Flt;
     231  opihi_int Int;
     232} dbValue;
    148233
    149234typedef struct {
    … …  
    225310// dvo DB field functions
    226311dbField     *dbCmdlineFields        PROTO((int argc, char **argv, int table, int *last, int *nfields));
     312int          dbCmdlineConditions    PROTO((int argc, char **argv, int first, int *nextField));
    227313dbStack     *dbRPN                  PROTO((int argc, char **argv, int *nstack));
    228314int          dbCheckStack           PROTO((dbStack *stack, int Nstack, int table, dbField **inFields, int *Nfields));
    229 int          dbBooleanCond          PROTO((dbStack *inStack, int NinStack, float *fields));
     315int          dbBooleanCond          PROTO((dbStack *inStack, int NinStack, dbValue *fields));
    230316void         dbInitStack            PROTO((dbStack *stack));
    231317void         dbFreeStack            PROTO((dbStack *stack, int Nstack));
    … …  
    233319void         dbFreeTempEntry        PROTO((dbStack *stack));
    234320
    235 dbStack     *dbBinary               PROTO((dbStack *V1, dbStack *V2, char *op, float *fields));
    236 dbStack     *dbUnary                PROTO((dbStack *V1, char *op, float *fields));
     321dbStack     *dbBinary               PROTO((dbStack *V1, dbStack *V2, char *op, dbValue *fields));
     322dbStack     *dbUnary                PROTO((dbStack *V1, char *op, dbValue *fields));
    237323
    238324int          GetMagMode             PROTO((char *string));
    … …  
    240326int          ParseMeasureField      PROTO((dbField *field, char *fieldName));
    241327int          ParseAverageField      PROTO((dbField *field, char *fieldName));
    242 
    243 double       dbExtractAverages      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
    244 double       dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
    245 void         dbExtractMeasuresInit  PROTO(());
     328int          ParseImageField        PROTO((dbField *field, char *fieldName));
     329
     330dbValue      dbExtractAverages      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
     331dbValue      dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
     332dbValue      dbExtractImages        PROTO((Image *image, int Nimage, int N, dbField *field));
    246333
    247334void         dbInitField            PROTO((dbField *field));
    … …  
    257344int wordhash (char *word);
    258345
    259 int dbExtractAverageInitTransform (CoordTransformSystem target);
    260 int dbExtractAverageInit ();
    261 
    262346int dbExtractMeasuresInitTransform (CoordTransformSystem target);
    263347int dbExtractMeasuresInitAve ();
    264348int dbExtractMeasuresInitMeas ();
     349int dbExtractMeasuresInit ();
    265350
    266351int dbExtractAveragesInitTransform (CoordTransformSystem target);
    267352int dbExtractAveragesInit ();
    268353
     354int dbExtractImagesInitTransform (CoordTransformSystem target);
     355int dbExtractImagesInit ();
     356int dbExtractImagesReset ();
     357
    269358# endif

  • trunk/Ohana/src/opihi/include/imfit.h

    r14590 r20936  
    33int Npar;
    44int Nfpar;
    5 float *par;
    6 float *fpar;
    7 float *sky;
     5opihi_flt *par;
     6opihi_flt *fpar;
     7opihi_flt *sky;
    88
    9 float (*fitfunc)(float, float, float *, int, float *);
     9opihi_flt (*fitfunc)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *);
    1010void (*imfit_cleanup)();
    1111

  • trunk/Ohana/src/opihi/include/pantasks.h

    r19125 r20936  
    245245int PrintControllerOutput ();
    246246
     247int AddHost (char *hostname, int max_threads);
     248int DeleteHost (char *hostname);
     249
     250int FlushControllerOutput ();
    247251int KillControllerJob (Job *job);
    248252int CheckControllerStatus ();

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

    r13479 r20936  
    11# include "display.h"
    22
    3 int PlotVectorPair (int kapa, int Npts, float *xValues, float *yValues, Graphdata *graphmode) {
     3int PlotVectorSingle (int kapa, Vector *vec, char *mode) {
    44
    5   KapaPrepPlot (kapa, Npts, graphmode);
    6   KapaPlotVector (kapa, Npts, xValues, "x");
    7   KapaPlotVector (kapa, Npts, yValues, "y");
     5  int i, Npts;
     6  float *temp;
     7
     8  Npts = vec->Nelements;
     9  ALLOCATE (temp, float, Npts);
     10
     11  if (vec->type == OPIHI_FLT) {
     12    opihi_flt *value = vec->elements.Flt;
     13    for (i = 0; i < Npts; i++) {
     14      temp[i] = value[i];
     15    }
     16  } else {
     17    opihi_int *value = vec->elements.Int;
     18    for (i = 0; i < Npts; i++) {
     19      temp[i] = value[i];
     20    }
     21  }
     22  KapaPlotVector (kapa, Npts, temp, mode);
     23
     24  free (temp);
    825
    926  return (TRUE);
    1027}
    1128
    12 int PlotVectorTriplet (int kapa, int Npts, float *xValues, float *yValues, float *zValues, Graphdata *graphmode) {
     29int PlotVectorPair (int kapa, Vector *xVec, Vector *yVec, Graphdata *graphmode) {
    1330
    14   KapaPrepPlot   (kapa, Npts, graphmode);
    15   KapaPlotVector (kapa, Npts, xValues, "x");
    16   KapaPlotVector (kapa, Npts, yValues, "y");
    17   KapaPlotVector (kapa, Npts, zValues, "z");
     31  int i, Npts;
     32  float *temp;
     33
     34  if (xVec->Nelements != yVec->Nelements) return (FALSE);
     35  Npts = xVec->Nelements;
     36
     37  ALLOCATE (temp, float, Npts);
     38
     39  KapaPrepPlot (kapa, Npts, graphmode);
     40
     41  if (xVec->type == OPIHI_FLT) {
     42    opihi_flt *value = xVec->elements.Flt;
     43    for (i = 0; i < Npts; i++) {
     44      temp[i] = value[i];
     45    }
     46  } else {
     47    opihi_int *value = xVec->elements.Int;
     48    for (i = 0; i < Npts; i++) {
     49      temp[i] = value[i];
     50    }
     51  }
     52  KapaPlotVector (kapa, Npts, temp, "x");
     53
     54  if (yVec->type == OPIHI_FLT) {
     55    opihi_flt *value = yVec->elements.Flt;
     56    for (i = 0; i < Npts; i++) {
     57      temp[i] = value[i];
     58    }
     59  } else {
     60    opihi_int *value = yVec->elements.Int;
     61    for (i = 0; i < Npts; i++) {
     62      temp[i] = value[i];
     63    }
     64  }
     65  KapaPlotVector (kapa, Npts, temp, "y");
     66
     67  free (temp);
    1868
    1969  return (TRUE);
    2070}
     71
     72int PlotVectorTriplet (int kapa, Vector *xVec, Vector *yVec, Vector *zVec, Graphdata *graphmode) {
     73
     74  int i, Npts;
     75  float *temp;
     76
     77  if (xVec->Nelements != yVec->Nelements) return (FALSE);
     78  if (xVec->Nelements != zVec->Nelements) return (FALSE);
     79  Npts = xVec->Nelements;
     80
     81  ALLOCATE (temp, float, Npts);
     82
     83  KapaPrepPlot (kapa, Npts, graphmode);
     84
     85  if (xVec->type == OPIHI_FLT) {
     86    opihi_flt *value = xVec->elements.Flt;
     87    for (i = 0; i < Npts; i++) {
     88      temp[i] = value[i];
     89    }
     90  } else {
     91    opihi_int *value = xVec->elements.Int;
     92    for (i = 0; i < Npts; i++) {
     93      temp[i] = value[i];
     94    }
     95  }
     96  KapaPlotVector (kapa, Npts, temp, "x");
     97
     98  if (yVec->type == OPIHI_FLT) {
     99    opihi_flt *value = yVec->elements.Flt;
     100    for (i = 0; i < Npts; i++) {
     101      temp[i] = value[i];
     102    }
     103  } else {
     104    opihi_int *value = yVec->elements.Int;
     105    for (i = 0; i < Npts; i++) {
     106      temp[i] = value[i];
     107    }
     108  }
     109  KapaPlotVector (kapa, Npts, temp, "y");
     110
     111  if (zVec->type == OPIHI_FLT) {
     112    opihi_flt *value = zVec->elements.Flt;
     113    for (i = 0; i < Npts; i++) {
     114      temp[i] = value[i];
     115    }
     116  } else {
     117    opihi_int *value = zVec->elements.Int;
     118    for (i = 0; i < Npts; i++) {
     119      temp[i] = value[i];
     120    }
     121  }
     122  KapaPlotVector (kapa, Npts, temp, "z");
     123
     124  free (temp);
     125
     126  return (TRUE);
     127}
     128
     129int PlotVectorPairErrors (int kapa, Vector *xVec, Vector *yVec, Vector *dyVec, Graphdata *graphmode) {
     130
     131  int i, Npts;
     132  float *temp;
     133
     134  if (xVec->Nelements != yVec->Nelements) return (FALSE);
     135  if (xVec->Nelements != dyVec->Nelements) return (FALSE);
     136  Npts = xVec->Nelements;
     137
     138  ALLOCATE (temp, float, Npts);
     139
     140  KapaPrepPlot (kapa, Npts, graphmode);
     141
     142  if (xVec->type == OPIHI_FLT) {
     143    opihi_flt *value = xVec->elements.Flt;
     144    for (i = 0; i < Npts; i++) {
     145      temp[i] = value[i];
     146    }
     147  } else {
     148    opihi_int *value = xVec->elements.Int;
     149    for (i = 0; i < Npts; i++) {
     150      temp[i] = value[i];
     151    }
     152  }
     153  KapaPlotVector (kapa, Npts, temp, "x");
     154
     155  if (yVec->type == OPIHI_FLT) {
     156    opihi_flt *value = yVec->elements.Flt;
     157    for (i = 0; i < Npts; i++) {
     158      temp[i] = value[i];
     159    }
     160  } else {
     161    opihi_int *value = yVec->elements.Int;
     162    for (i = 0; i < Npts; i++) {
     163      temp[i] = value[i];
     164    }
     165  }
     166  KapaPlotVector (kapa, Npts, temp, "y");
     167
     168  if (dyVec->type == OPIHI_FLT) {
     169    opihi_flt *value = dyVec->elements.Flt;
     170    for (i = 0; i < Npts; i++) {
     171      temp[i] = value[i];
     172    }
     173  } else {
     174    opihi_int *value = dyVec->elements.Int;
     175    for (i = 0; i < Npts; i++) {
     176      temp[i] = value[i];
     177    }
     178  }
     179  KapaPlotVector (kapa, Npts, temp, "dym");
     180  KapaPlotVector (kapa, Npts, temp, "dyp");
     181
     182  free (temp);
     183
     184  return (TRUE);
     185}
     186

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

    r17902 r20936  
    133133}
    134134
     135// fft based on code by Douglas L. Jones (see note at EOF). modified for Ohana C style
     136void dfft1D (double *x, double *y, int n, int Nbit, int forward) {
     137
     138  int i,j,k,n1,n2;
     139  double c,s,e,a,t1,t2;       
     140  double factor;
     141         
     142  // bit-reverse
     143  j = 0;
     144  n2 = n/2;
     145  for (i = 1; i < n - 1; i++) {
     146    n1 = n2;
     147    while ( j >= n1 ) {
     148      j -= n1;
     149      n1 /= 2;
     150    }
     151    j += n1;
     152               
     153    if (i < j) {
     154      t1 = x[i];
     155      x[i] = x[j];
     156      x[j] = t1;
     157      t1 = y[i];
     158      y[i] = y[j];
     159      y[j] = t1;
     160    }
     161  }
     162                                         
     163  n1 = 0; /* FFT */
     164  n2 = 1;
     165                                             
     166  if (forward) {
     167    factor = +2.0*M_PI;
     168  } else {
     169    factor = -2.0*M_PI;
     170  }
     171
     172  for (i=0; i < Nbit; i++) {
     173    n1 = n2;
     174    n2 = n2 + n2;
     175    e = factor/n2;
     176    a = 0.0;
     177                                             
     178    for (j=0; j < n1; j++) {
     179      c = cos(a);
     180      s = sin(a);
     181      a = a + e;
     182                                           
     183      for (k=j; k < n; k=k+n2) {
     184        t1 = c*x[k+n1] - s*y[k+n1];
     185        t2 = s*x[k+n1] + c*y[k+n1];
     186        x[k+n1] = x[k] - t1;
     187        y[k+n1] = y[k] - t2;
     188        x[k] = x[k] + t1;
     189        y[k] = y[k] + t2;
     190      }
     191    }
     192  }
     193                                     
     194  // re-normalize
     195  for (i = 0; i < n; i++) {
     196    x[i] /= n;
     197    y[i] /= n;
     198  }
     199
     200  return;
     201}                         
     202
     203// This implementation uses the 1-D fft above for each of the vectors in each dimension.
     204// This requires 2(Nx*Ny*...) mem copies, but the fft operations are likely to happen in
     205// cache.
     206int dfftND (double *x, double *y, int Ndim, int *Nsize, int forward) {
     207
     208  int i, nIndex, minor, major, iDim;
     209  int step, Nmajor, Nminor, Nmax, Ntotal;
     210  int *Nbit;
     211  double *tmpX, *tmpY;
     212
     213  ALLOCATE (Nbit, int, Ndim);
     214
     215  // find the longest axis and allocate storage for that length
     216  Nmax = 0;
     217  Ntotal = 1;
     218  for (i = 0; i < Ndim; i++) {
     219    Nmax = MAX(Nmax, Nsize[i]);
     220    Ntotal *= Nsize[i];
     221    if (!IsBinary (Nsize[i], &Nbit[i])) {
     222      free (Nbit);
     223      return (FALSE);
     224    }
     225  }
     226  ALLOCATE (tmpX, double, Nmax);
     227  ALLOCATE (tmpY, double, Nmax);
     228 
     229  step = 1;
     230  Nminor = 1;
     231  Nmajor = Ntotal;
     232  for (iDim = 0; iDim < Ndim; iDim++) {
     233    step *= Nsize[iDim];
     234    Nmajor /= Nsize[iDim];
     235
     236    // we perform the FFT along all other dimensions
     237    for (major = 0; major < Nmajor; major++) {
     238      for (minor = 0; minor < Nminor; minor++) {
     239        // nIndex = minor + i*Nminor + major*step;
     240        // extract the data values to the temp vector
     241        nIndex = minor + major*step;
     242        for (i = 0; i < Nsize[iDim]; i++) {
     243          tmpX[i] = x[nIndex];
     244          tmpY[i] = y[nIndex];
     245          nIndex += Nminor;
     246        }
     247
     248        dfft1D (tmpX, tmpY, Nsize[iDim], Nbit[iDim], forward);
     249
     250        // replace the result vectors
     251        nIndex = minor + major*step;
     252        for (i = 0; i < Nsize[iDim]; i++) {
     253          x[nIndex] = tmpX[i];
     254          y[nIndex] = tmpY[i];
     255          nIndex += Nminor;
     256        }
     257      }
     258    }
     259    Nminor *= Nsize[iDim];
     260  }
     261  free (Nbit);
     262  free (tmpX);
     263  free (tmpY);
     264  return (TRUE);
     265}
     266
    135267// check that a number is binary (2^Nbit).  returns int(log_2(N)) in Nbit
    136268int IsBinary (int N, int *Nbit) {

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

    r13479 r20936  
    11# include "data.h"
    22
     3// XXX need to select the active vector for the range analysis
     4// this function accepts either FLT or INT vectors
    35void SetLimits (Vector *xvec, Vector *yvec, Graphdata *graphmode) {
    46
    … …  
    79
    810  if (xvec != NULL) {
    9     maxX = minX = xvec[0].elements[0];
    10     for (i = 1; i < xvec[0].Nelements; i++) {
    11       if (!finite(xvec[0].elements[i])) continue;
    12       maxX = MAX (maxX, xvec[0].elements[i]);
    13       minX = MIN (minX, xvec[0].elements[i]);
     11    if (xvec->type == OPIHI_FLT) {
     12      maxX = minX = xvec[0].elements.Flt[0];
     13      for (i = 1; i < xvec[0].Nelements; i++) {
     14        if (!finite(xvec[0].elements.Flt[i])) continue;
     15        maxX = MAX (maxX, xvec[0].elements.Flt[i]);
     16        minX = MIN (minX, xvec[0].elements.Flt[i]);
     17      }
     18    } else {
     19      maxX = minX = xvec[0].elements.Int[0];
     20      for (i = 1; i < xvec[0].Nelements; i++) {
     21        if (!finite(xvec[0].elements.Int[i])) continue;
     22        maxX = MAX (maxX, xvec[0].elements.Int[i]);
     23        minX = MIN (minX, xvec[0].elements.Int[i]);
     24      }
    1425    }
    1526    range = maxX - minX;
    … …  
    2132
    2233  if (yvec != NULL) {
    23     maxY = minY = yvec[0].elements[0];
    24     for (i = 1; i < yvec[0].Nelements; i++) {
    25       if (!finite(yvec[0].elements[i])) continue;
    26       maxY = MAX (maxY, yvec[0].elements[i]);
    27       minY = MIN (minY, yvec[0].elements[i]);
     34    if (yvec->type == OPIHI_FLT) {
     35      maxY = minY = yvec[0].elements.Flt[0];
     36      for (i = 1; i < yvec[0].Nelements; i++) {
     37        if (!finite(yvec[0].elements.Flt[i])) continue;
     38        maxY = MAX (maxY, yvec[0].elements.Flt[i]);
     39        minY = MIN (minY, yvec[0].elements.Flt[i]);
     40      }
     41    } else {
     42      maxY = minY = yvec[0].elements.Int[0];
     43      for (i = 1; i < yvec[0].Nelements; i++) {
     44        if (!finite(yvec[0].elements.Int[i])) continue;
     45        maxY = MAX (maxY, yvec[0].elements.Int[i]);
     46        minY = MIN (minY, yvec[0].elements.Int[i]);
     47      }
    2848    }
    2949    range = maxY - minY;

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

    r16059 r20936  
    99# define VERY_VERBOSE 0
    1010
    11 static float **alpha, **talpha;
    12 static float **beta, **tbeta;
    13 static float *partry, *dyda;
    14 static float ochisq, lambda;
    15 
    16 static float *parmin = NULL;
    17 static float *parmax = NULL;
    18 
    19 float mrq2dcof (float *x, float *t, float *y, float *dy, int Npts,
    20               float *par, int Npar, float **ta, float **tb,
    21               float (funcs)(float, float, float *, int, float *)) {
     11static opihi_flt **alpha, **talpha;
     12static opihi_flt **beta, **tbeta;
     13static opihi_flt *partry, *dyda;
     14static opihi_flt ochisq, lambda;
     15
     16static opihi_flt *parmin = NULL;
     17static opihi_flt *parmax = NULL;
     18
     19opihi_flt mrq2dcof (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     20              opihi_flt *par, int Npar, opihi_flt **ta, opihi_flt **tb,
     21              opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *)) {
    2222
    2323  int k, j, i;
    24   float ydiff, wt, chisq;
     24  opihi_flt ydiff, wt, chisq;
    2525
    2626  for (j = 0; j < Npar; j++) {
    … …  
    6060}
    6161
    62 float mrq2dchi (float *x, float *t, float *y, float *dy, int Npts,
    63                 float *par, int Npar,
    64                 float (funcs)(float, float, float *, int, float *)) {
    65 
    66   int i;
    67   float ydiff, chisq;
     62opihi_flt mrq2dchi (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     63                opihi_flt *par, int Npar,
     64                opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *)) {
     65
     66  int i;
     67  opihi_flt ydiff, chisq;
    6868
    6969  chisq = 0.0;
    … …  
    7575}
    7676
    77 float mrq2dmin (float *x, float *t, float *y, float *dy, int Npts,
    78               float *par, int Npar,
    79               float (funcs)(float, float, float *, int, float *), int VERBOSE) {
     77opihi_flt mrq2dmin (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     78              opihi_flt *par, int Npar,
     79              opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE) {
    8080
    8181  int j, k;
    82   float chisq;
     82  opihi_flt chisq;
    8383
    8484  /* set up test matrixes for this run */
    … …  
    9090
    9191  /* keep this test in here? */
    92   if (!fgaussjordan (talpha, tbeta, Npar, 1)) {
     92  if (!dgaussjordan (talpha, tbeta, Npar, 1)) {
    9393    lambda *= 10.0;
    9494    return (ochisq);
    … …  
    131131}
    132132
    133 int mrq2dlimits (float *pmin, float *pmax, int Npar) {
    134 
    135   int i;
    136 
    137   ALLOCATE (parmin, float, Npar);
    138   ALLOCATE (parmax, float, Npar);
     133int mrq2dlimits (opihi_flt *pmin, opihi_flt *pmax, int Npar) {
     134
     135  int i;
     136
     137  ALLOCATE (parmin, opihi_flt, Npar);
     138  ALLOCATE (parmax, opihi_flt, Npar);
    139139  for (i = 0; i < Npar; i++) {
    140140    parmin[i] = pmin[i];
    … …  
    144144}
    145145
    146 float mrq2dinit (float *x, float *t, float *y, float *dy, int Npts,
    147               float *par, int Npar,
    148               float (funcs)(float, float, float *, int, float *), int VERBOSE) {
    149 
    150   int i;
    151 
    152   ALLOCATE (dyda, float, Npar);
    153   ALLOCATE (partry, float, Npar);
    154   ALLOCATE (alpha, float *, Npar);
    155   ALLOCATE (beta, float *, Npar);
    156   ALLOCATE (talpha, float *, Npar);
    157   ALLOCATE (tbeta, float *, Npar);
     146opihi_flt mrq2dinit (opihi_flt *x, opihi_flt *t, opihi_flt *y, opihi_flt *dy, int Npts,
     147              opihi_flt *par, int Npar,
     148              opihi_flt (funcs)(opihi_flt, opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE) {
     149
     150  int i;
     151
     152  ALLOCATE (dyda, opihi_flt, Npar);
     153  ALLOCATE (partry, opihi_flt, Npar);
     154  ALLOCATE (alpha, opihi_flt *, Npar);
     155  ALLOCATE (beta, opihi_flt *, Npar);
     156  ALLOCATE (talpha, opihi_flt *, Npar);
     157  ALLOCATE (tbeta, opihi_flt *, Npar);
    158158  for (i = 0; i < Npar; i++) {
    159     ALLOCATE (alpha[i], float, Npar);
    160     ALLOCATE (beta[i], float, Npar);
    161     ALLOCATE (talpha[i], float, Npar);
    162     ALLOCATE (tbeta[i], float, Npar);
     159    ALLOCATE (alpha[i], opihi_flt, Npar);
     160    ALLOCATE (beta[i], opihi_flt, Npar);
     161    ALLOCATE (talpha[i], opihi_flt, Npar);
     162    ALLOCATE (tbeta[i], opihi_flt, Npar);
    163163  }
    164164
    … …  
    181181
    182182/* don't invoke this in the middle of a run, only near the end */
    183 float **mrq2dcovar (int Npar) {
    184 
    185   fgaussjordan (alpha, beta, Npar, 1);
     183opihi_flt **mrq2dcovar (int Npar) {
     184
     185  dgaussjordan (alpha, beta, Npar, 1);
    186186  return (alpha);
    187187

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

    r16059 r20936  
    77*/
    88
    9 static float **alpha, **talpha;
    10 static float **beta, **tbeta;
    11 static float *partry, *dyda;
    12 static float ochisq, lambda;
     9static opihi_flt **alpha, **talpha;
     10static opihi_flt **beta, **tbeta;
     11static opihi_flt *partry, *dyda;
     12static opihi_flt ochisq, lambda;
    1313
    14 float mrqcof (float *x, float *y, float *dy, int Npts,
    15               float *par, int Npar, float **ta, float **tb,
    16               float (funcs)(float, float *, int, float *)) {
     14opihi_flt mrqcof (opihi_flt *x, opihi_flt *y, opihi_flt *dy, int Npts,
     15              opihi_flt *par, int Npar, opihi_flt **ta, opihi_flt **tb,
     16              opihi_flt (funcs)(opihi_flt, opihi_flt *, int, opihi_flt *)) {
    1717
    1818  int k, j, i;
    19   float ydiff, wt, chisq;
     19  opihi_flt ydiff, wt, chisq;
    2020
    2121  for (j = 0; j < Npar; j++) {
    … …  
    4545}
    4646
    47 float mrqmin (float *x, float *y, float *dy, int Npts,
    48               float *par, int Npar,
    49               float (funcs)(float, float *, int, float *), int VERBOSE) {
     47opihi_flt mrqmin (opihi_flt *x, opihi_flt *y, opihi_flt *dy, int Npts,
     48              opihi_flt *par, int Npar,
     49              opihi_flt (funcs)(opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE) {
    5050
    5151  int j, k;
    52   float chisq;
    53   float rho, dX, dL;
     52  opihi_flt chisq;
     53  opihi_flt rho, dX, dL;
    5454
    5555  /* set up test matrixes for this run */
    … …  
    6060  }
    6161
    62   fgaussjordan (talpha, tbeta, Npar, 1);
     62  dgaussjordan (talpha, tbeta, Npar, 1);
    6363
    6464  for (j = 0; j < Npar; j++) partry[j] = par[j] - tbeta[j][0];
    … …  
    102102}
    103103
    104 float mrqinit (float *x, float *y, float *dy, int Npts,
    105               float *par, int Npar,
    106               float (funcs)(float, float *, int, float *), int VERBOSE) {
     104opihi_flt mrqinit (opihi_flt *x, opihi_flt *y, opihi_flt *dy, int Npts,
     105              opihi_flt *par, int Npar,
     106              opihi_flt (funcs)(opihi_flt, opihi_flt *, int, opihi_flt *), int VERBOSE) {
    107107
    108108  int i;
    109109
    110   ALLOCATE (dyda, float, Npar);
    111   ALLOCATE (partry, float, Npar);
    112   ALLOCATE (alpha, float *, Npar);
    113   ALLOCATE (beta, float *, Npar);
    114   ALLOCATE (talpha, float *, Npar);
    115   ALLOCATE (tbeta, float *, Npar);
     110  ALLOCATE (dyda, opihi_flt, Npar);
     111  ALLOCATE (partry, opihi_flt, Npar);
     112  ALLOCATE (alpha, opihi_flt *, Npar);
     113  ALLOCATE (beta, opihi_flt *, Npar);
     114  ALLOCATE (talpha, opihi_flt *, Npar);
     115  ALLOCATE (tbeta, opihi_flt *, Npar);
    116116  for (i = 0; i < Npar; i++) {
    117     ALLOCATE (alpha[i], float, Npar);
    118     ALLOCATE (beta[i], float, Npar);
    119     ALLOCATE (talpha[i], float, Npar);
    120     ALLOCATE (tbeta[i], float, Npar);
     117    ALLOCATE (alpha[i], opihi_flt, Npar);
     118    ALLOCATE (beta[i], opihi_flt, Npar);
     119    ALLOCATE (talpha[i], opihi_flt, Npar);
     120    ALLOCATE (tbeta[i], opihi_flt, Npar);
    121121  }
    122122 
    … …  
    136136
    137137/* don't invoke this in the middle of a run, only near the end */
    138 float **mrqcovar (int Npar) {
    139   fgaussjordan (alpha, beta, Npar, 1);
     138opihi_flt **mrqcovar (int Npar) {
     139  dgaussjordan (alpha, beta, Npar, 1);
    140140  return (alpha);
    141141}

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

    r19827 r20936  
    119119/* use a circular aperture */
    120120int get_rough_star (float *data, int Nx, int Ny, int x, int y,
    121                     float *xc, float *yc,
    122                     float *sx, float *sy, float *sxy,
    123                     float *zs, float *zp, float *sk) {
     121                    opihi_flt *xc, opihi_flt *yc,
     122                    opihi_flt *sx, opihi_flt *sy, opihi_flt *sxy,
     123                    opihi_flt *zs, opihi_flt *zp, opihi_flt *sk) {
    124124
    125125  double Ra2, Ri2, Ro2, rad2;

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

    r4689 r20936  
    1212
    1313/* n == Nx, m == Ny */
    14 int svdcmp (float *a, float *w, float *v, int Nx, int Ny) {
     14int svdcmp (float *a, opihi_flt *w, float *v, int Nx, int Ny) {
    1515
    1616  int flag, i, its, j, jj, k, l, nm, status;

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

    r16887 r20936  
    11# include "opihi.h"
     2
     3// NOTE: we refer to elements.Ptr if we do not care about the actual type
    24
    35static Vector **vectors;
    … …  
    1820
    1921  for (i = 0; i < Nvectors; i++) {
    20     free (vectors[i][0].elements);
     22    if (vectors[i][0].elements.Int) {
     23      free (vectors[i][0].elements.Int);
     24    }
    2125    free (vectors[i]);
    2226  }
    … …  
    2832
    2933  ALLOCATE (vec, Vector, 1);
    30   ALLOCATE (vec[0].elements, float, 1);
    31   bzero (vec[0].name, 1024);
     34
     35  vec[0].type = OPIHI_FLT;    // is a float unless specified otherwise
     36  ALLOCATE (vec[0].elements.Flt, opihi_flt, 1);
     37
     38  bzero (vec[0].name, OPIHI_NAME_SIZE);
    3239  vec[0].Nelements = 0;
    3340  return (vec);
    … …  
    5663}
    5764
     65// XXX add TYPE to arguments?
    5866Vector *SelectVector (char *name, int mode, int verbose) {
    5967
    … …  
    95103  if (i == Nvectors) return (FALSE);
    96104
    97   free (vectors[i][0].elements);
     105  if (vectors[i][0].elements.Ptr) free (vectors[i][0].elements.Ptr);
    98106  free (vectors[i]);
    99107
    … …  
    115123  if (i == Nvectors) return (FALSE);
    116124
    117   free (vectors[i][0].elements);
     125  if (vectors[i][0].elements.Ptr) free (vectors[i][0].elements.Ptr);
    118126  free (vectors[i]);
    119127
    … …  
    134142  return (TRUE);
    135143}
     144
    136145int CopyVector (Vector *out, Vector *in) {
    137   free (out[0].elements);
     146  if (out[0].elements.Ptr) free (out[0].elements.Ptr);
    138147  out[0].Nelements = in[0].Nelements;
    139   ALLOCATE (out[0].elements, float, out[0].Nelements);
    140   memcpy (out[0].elements, in[0].elements, out[0].Nelements*sizeof(float));
    141   return (TRUE);
     148  if (in[0].elements.Ptr) {
     149    if (in[0].type == OPIHI_FLT) {
     150      ALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
     151      memcpy (out[0].elements.Flt, in[0].elements.Flt, out[0].Nelements*sizeof(opihi_flt));
     152      out[0].type = OPIHI_FLT;
     153    } else {
     154      ALLOCATE (out[0].elements.Int, opihi_int, out[0].Nelements);
     155      memcpy (out[0].elements.Int, in[0].elements.Int, out[0].Nelements*sizeof(opihi_int));
     156      out[0].type = OPIHI_INT;
     157    }
     158  }
     159  return (TRUE);
     160}
     161
     162int MatchVector(Vector *out, Vector *in, char type) {
     163  if (out[0].elements.Ptr) free (out[0].elements.Ptr);
     164  out[0].Nelements = in[0].Nelements;
     165  if (type == OPIHI_FLT) {
     166    ALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
     167    out[0].type = OPIHI_FLT;
     168  } else {
     169    ALLOCATE (out[0].elements.Int, opihi_int, out[0].Nelements);
     170    out[0].type = OPIHI_INT;
     171  }
     172  return (TRUE);
     173}
     174
     175// ResetVector (vecx, OPIHI_FLT, MAX (Npts, 1));
     176int ResetVector (Vector *vec, char type, int Nelements) {
     177
     178  vec[0].Nelements = Nelements;
     179  if (type == OPIHI_FLT) {
     180    REALLOCATE (vec[0].elements.Flt, opihi_flt, Nelements);
     181    vec[0].type = OPIHI_FLT;
     182  } else {
     183    REALLOCATE (vec[0].elements.Int, opihi_int, Nelements);
     184    vec[0].type = OPIHI_INT;
     185  }
     186  return TRUE;
     187}
     188
     189// SetVector (vecx, OPIHI_FLT, MAX (Npts, 1));
     190int SetVector (Vector *vec, char type, int Nelements) {
     191
     192  vec[0].Nelements = Nelements;
     193  if (type == OPIHI_FLT) {
     194    ALLOCATE (vec[0].elements.Flt, opihi_flt, Nelements);
     195    vec[0].type = OPIHI_FLT;
     196  } else {
     197    ALLOCATE (vec[0].elements.Int, opihi_int, Nelements);
     198    vec[0].type = OPIHI_INT;
     199  }
     200  return TRUE;
     201}
     202
     203// recast the vector to the specified type
     204int CastVector (Vector *vec, char type) {
     205
     206  int i;
     207
     208  // the trivial case
     209  if (vec[0].type == type) return TRUE;
     210
     211  if (type == OPIHI_FLT) {
     212    opihi_flt *temp;
     213    ALLOCATE (temp, opihi_flt, vec[0].Nelements);
     214    opihi_flt *vo = temp;
     215    opihi_int *vi = vec[0].elements.Int;
     216    for (i = 0; i < vec[0].Nelements; i++, vo++, vi++) {
     217      *vo = *vi;
     218    }
     219    free (vec[0].elements.Int);
     220    vec[0].elements.Flt = vo;
     221    vec[0].type = OPIHI_FLT;
     222  } else {
     223    opihi_int *temp;
     224    ALLOCATE (temp, opihi_int, vec[0].Nelements);
     225    opihi_int *vo = temp;
     226    opihi_flt *vi = vec[0].elements.Flt;
     227    for (i = 0; i < vec[0].Nelements; i++, vo++, vi++) {
     228      *vo = *vi;
     229    }
     230    free (vec[0].elements.Flt);
     231    vec[0].elements.Int = vo;
     232    vec[0].type = OPIHI_INT;
     233  }
     234  return TRUE;
    142235}
    143236
    … …  
    150243  return (TRUE);
    151244}
     245
    152246int MoveVector (Vector *out, Vector *in) {
    153247  int i, j;
    154248
    155   free (out[0].elements);
    156   out[0].Nelements = in[0].Nelements;
    157   out[0].elements =  in[0].elements;
     249  if (out[0].elements.Ptr) free (out[0].elements.Ptr);
     250  out[0].Nelements    = in[0].Nelements;
     251  out[0].elements.Ptr = in[0].elements.Ptr;
     252  out[0].type         = in[0].type;
    158253
    159254  /* delete vector entry from vector list, if it exists */
    … …  
    184279  gprint (GP_LOG, "    N       name      size\n");
    185280  for (i = 0; i < Nvectors; i++) {
    186     gprint (GP_LOG, "%5d %10s %10d\n",
    187              i, vectors[i][0].name, vectors[i][0].Nelements);
    188   }
    189   return (TRUE);
    190 }
    191  
     281    if (vectors[i][0].type == OPIHI_FLT) {
     282      gprint (GP_LOG, "%5d %10s %10d (FLT)\n", i, vectors[i][0].name, vectors[i][0].Nelements);
     283    } else {
     284      gprint (GP_LOG, "%5d %10s %10d (INT)\n", i, vectors[i][0].name, vectors[i][0].Nelements);
     285    }
     286  }
     287  return (TRUE);
     288}
     289 

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

    r6250 r20936  
    44
    55  int i, Nx, Ny, Nv, size;
    6   char *c;
     6  char *c1, *c2;
    77
    88  Nv = Nx = Ny = -1;
    … …  
    1111    if (stack[i].type == 'X') {
    1212
    13       /** if this is a number, put it on the list of scalers and move on **/
    14       stack[i].Float = strtod (stack[i].name, &c);
    15       if (c == stack[i].name + strlen (stack[i].name)) {
    16         stack[i].ptr   = &(stack[i].Float);
    17         stack[i].type  = 'S';
     13      /** if this is a number, put it on the list of scalars and move on.  assume value is
     14       * an int unless proven otherwise **/
     15      stack[i].FltValue = strtod (stack[i].name, &c1);
     16      stack[i].IntValue = strtol (stack[i].name, &c2, 0);
     17      if (c2 == stack[i].name + strlen (stack[i].name)) {
     18        stack[i].type  = 's'; // 's' == (int)
     19        continue;
     20      }
     21      if (c1 == stack[i].name + strlen (stack[i].name)) {
     22        stack[i].type  = 'S'; // 'S' == (float)
    1823        continue;
    1924      }
    … …  
    2227      if (IsBuffer (stack[i].name)) {
    2328        stack[i].buffer = SelectBuffer (stack[i].name, OLDBUFFER, TRUE);
    24         stack[i].ptr    = (float *) stack[i].buffer[0].matrix.buffer;
    2529        stack[i].type   = 'M';
    2630        if (Nx == -1) {
    … …  
    4448      if (IsVector (stack[i].name)) {
    4549        stack[i].vector = SelectVector (stack[i].name, OLDVECTOR, FALSE);
    46         stack[i].ptr    = (float *) stack[i].vector[0].elements;
    4750        stack[i].type   = 'V';
    4851

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

    r14708 r20936  
    7676    case 0:
    7777      if (Ncstack == 1) {
    78           /* use exact input work */
    79           sprintf (outname, "%s", stack[0].name);
     78        /* use exact input word */
     79        sprintf (outname, "%s", stack[0].name);
    8080      } else {
    81           sprintf (outname, "%.12g", stack[0].Float);
     81        if (stack[0].type == 's') {
     82          sprintf (outname, "%d", stack[0].IntValue);
     83        } else {
     84          sprintf (outname, "%.12g", stack[0].FltValue);
     85        }
    8286      }
    8387      break;

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

    r18078 r20936  
    2121
    2222  if (*Nstack == 1) {
    23     if (stack[0].type == 'S') {
     23    if ((stack[0].type == 'S') || (stack[0].type == 's')) {
    2424      clear_stack (&tmp_stack);
    2525      return (TRUE);
    … …  
    140140/* copy data to new stack variable */
    141141void copy_stack (StackVar *stack1, StackVar *stack2) {
    142   stack1[0].name   = stack2[0].name  ;
    143   stack1[0].type   = stack2[0].type  ;
    144   stack1[0].ptr    = stack2[0].ptr   ;
    145   stack1[0].buffer = stack2[0].buffer;
    146   stack1[0].vector = stack2[0].vector;
    147   stack1[0].Float  = stack2[0].Float ;
    148   if (!strncasecmp (&stack1[0].type, "S", 1)) {
    149     stack1[0].ptr    = &stack1[0].Float;
    150   }
     142  stack1[0].name     = stack2[0].name  ;
     143  stack1[0].type     = stack2[0].type  ;
     144  stack1[0].buffer   = stack2[0].buffer;
     145  stack1[0].vector   = stack2[0].vector;
     146  stack1[0].FltValue = stack2[0].FltValue;
     147  stack1[0].IntValue = stack2[0].IntValue;
    151148}
    152149
    … …  
    173170    if (IsVectorPtr (stack[i].vector) && (stack[i].type == 'v')) {
    174171      if (VERBOSE) gprint (GP_ERR, "free %s (vect) (%lx)\n", stack[i].name, (long) stack[i].vector);
    175       free (stack[i].vector[0].elements);
     172      free (stack[i].vector[0].elements.Ptr);
    176173      free (stack[i].vector);
    177174      stack[i].vector = NULL;

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

    r17247 r20936  
    126126        }
    127127        if (I < 0) I += vec[0].Nelements;
    128         f1 = vec[0].elements[I];
     128        f1 = (vec[0].type == OPIHI_FLT) ? vec[0].elements.Flt[I] : vec[0].elements.Int[I];
    129129      }
    130130    }
    … …  
    132132    free (tmpline);
    133133    if ((int)f1 == f1)
    134       snprintf (strValue, 128, "%.0f", f1);
     134      snprintf (strValue, 128, "%.0f", f1); 
    135135    else
    136       snprintf (strValue, 128, "%.9g", f1);
     136      snprintf (strValue, 128, "%.12g", f1);
    137137
    138138    /* interpolate vector element into newline (being accumulated) */

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

    r16059 r20936  
    190190      }
    191191      if (Nx < 0) Nx += vec[0].Nelements;
    192       vec[0].elements[Nx] = atof (val);
     192      if (vec[0].type == OPIHI_FLT) {
     193        vec[0].elements.Flt[Nx] = atof (val);
     194      } else {
     195        vec[0].elements.Int[Nx] = atol (val);
     196      }
    193197    }
    194198

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

    r18078 r20936  
    44   labeled by "m". if one of the input matrices is already a temp variable, we
    55   can continue using it this round
    6    */
     6*/
     7
     8// XXX we temporarily drop the concept of using one of the temporary input vectors for
     9// the output vector (thus saving an ALLOC): we have to juggle the size of the input vectors
     10// as well as their temporary state
    711
    812int VV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    913
    1014  int i, Nx;
    11   float *out, *M1, *M2;
     15  char line[512]; // this is only used to report an error
     16 
     17  // the vectors have to match in length
     18  if (V1[0].vector[0].Nelements != V2[0].vector[0].Nelements) {
     19    return (FALSE);
     20  }
     21
     22  Nx = V1[0].vector[0].Nelements;
     23
     24  // create the output vector guaranteed to be temporary until the very end
     25  OUT[0].vector = InitVector ();
     26  OUT[0].type = 'v';
     27
     28  // set up the possible operations : int OP int -> int, all else yield float
     29  // OP is the operation performed on *M1 and *M2
     30# define VV_FUNC(FTYPE,OP) {                                            \
     31    if ((V1->vector->type == OPIHI_FLT) && (V2->vector->type == OPIHI_FLT)) { \
     32      CopyVector (OUT[0].vector, V1[0].vector);                         \
     33      opihi_flt *M1  =  V1[0].vector[0].elements.Flt;                   \
     34      opihi_flt *M2  =  V2[0].vector[0].elements.Flt;                   \
     35      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     36      for (i = 0; i < Nx; i++, out++, M1++, M2++) {                     \
     37        *out = OP;                                                      \
     38      }                                                                 \
     39      break;                                                            \
     40    }                                                                   \
     41    if ((V1->vector->type == OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \
     42      CopyVector (OUT[0].vector, V1[0].vector);                         \
     43      opihi_flt *M1  =  V1[0].vector[0].elements.Flt;                   \
     44      opihi_int *M2  =  V2[0].vector[0].elements.Int;                   \
     45      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     46      for (i = 0; i < Nx; i++, out++, M1++, M2++) {                     \
     47        *out = OP;                                                      \
     48      }                                                                 \
     49      break;                                                            \
     50    }                                                                   \
     51    if ((V1->vector->type != OPIHI_FLT) && (V2->vector->type == OPIHI_FLT)) { \
     52      CopyVector (OUT[0].vector, V2[0].vector);                         \
     53      opihi_int *M1  =  V1[0].vector[0].elements.Int;                   \
     54      opihi_flt *M2  =  V2[0].vector[0].elements.Flt;                   \
     55      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     56      for (i = 0; i < Nx; i++, out++, M1++, M2++) {                     \
     57        *out = OP;                                                      \
     58      }                                                                 \
     59      break;                                                            \
     60    }                                                                   \
     61    if ((FTYPE == 'S') && (V1->vector->type != OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \
     62      MatchVector (OUT[0].vector, V1[0].vector, OPIHI_FLT);             \
     63      opihi_int *M1  =  V1[0].vector[0].elements.Int;                   \
     64      opihi_int *M2  =  V2[0].vector[0].elements.Int;                   \
     65      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     66      for (i = 0; i < Nx; i++, out++, M1++, M2++) {                     \
     67        *out = OP;                                                      \
     68      }                                                                 \
     69      break;                                                            \
     70    }                                                                   \
     71    if ((V1->vector->type != OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \
     72      CopyVector (OUT[0].vector, V1[0].vector);                         \
     73      opihi_int *M1  =  V1[0].vector[0].elements.Int;                   \
     74      opihi_int *M2  =  V2[0].vector[0].elements.Int;                   \
     75      opihi_int *out = OUT[0].vector[0].elements.Int;                   \
     76      for (i = 0; i < Nx; i++, out++, M1++, M2++) {                     \
     77        *out = OP;                                                      \
     78      }                                                                 \
     79      break;                                                            \
     80    }                                                                   \
     81  }
     82
     83  switch (op[0]) {
     84    case '+': VV_FUNC('s', *M1 + *M2);
     85    case '-': VV_FUNC('s', *M1 - *M2);
     86    case '*': VV_FUNC('s', *M1 * *M2);
     87    case '/': VV_FUNC('S', *M1 / (opihi_flt) *M2);
     88    case '%': VV_FUNC('s', (int)*M1 % (int)*M2);
     89    case '^': VV_FUNC('S', pow (*M1, *M2));
     90    case '@': VV_FUNC('S', DEG_RAD*atan2 (*M1, *M2));
     91    case 'D': VV_FUNC('s', MIN (*M1, *M2));
     92    case 'U': VV_FUNC('s', MAX (*M1, *M2));
     93    case '<': VV_FUNC('s', (*M1 < *M2) ? 1 : 0);
     94    case '>': VV_FUNC('s', (*M1 > *M2) ? 1 : 0);
     95    case '&': VV_FUNC('s', ((int)*M1 & (int)*M2));
     96    case '|': VV_FUNC('s', ((int)*M1 | (int)*M2));
     97    case 'E': VV_FUNC('s', (*M1 == *M2) ? 1 : 0);
     98    case 'N': VV_FUNC('s', (*M1 != *M2) ? 1 : 0);
     99    case 'L': VV_FUNC('s', (*M1 <= *M2) ? 1 : 0);
     100    case 'G': VV_FUNC('s', (*M1 >= *M2) ? 1 : 0);
     101    case 'A': VV_FUNC('s', (*M1 && *M2) ? 1 : 0);
     102    case 'O': VV_FUNC('s', (*M1 || *M2) ? 1 : 0);
     103    default:
     104      sprintf (line, "error: op %c not defined!", op[0]);
     105      push_error (line);
     106      return (FALSE);
     107  }
     108# undef VV_FUNC
     109
     110  /** free up any temporary buffers: **/
     111
     112  if (V1[0].type == 'v') {
     113    free (V1[0].vector[0].elements.Ptr);
     114    free (V1[0].vector);
     115  }
     116  if (V2[0].type == 'v') {
     117    free (V2[0].vector[0].elements.Ptr);
     118    free (V2[0].vector);
     119  }
     120  /* at the end, V1 and V2 are deleted only if they were temporary */
     121
     122  clear_stack (V1);
     123  clear_stack (V2);
     124  return (TRUE);
     125
     126}
     127
     128int SV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
     129
     130  int i, Nx;
     131  char line[512]; // this is only used to report an error
     132 
     133  Nx = V2[0].vector[0].Nelements;
     134
     135  OUT[0].vector = InitVector ();
     136  OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
     137
     138  // set up the possible operations : int OP int -> int, all else yield float
     139  // OP is the operation performed on *M1 and *M2
     140# define SV_FUNC(FTYPE,OP) {                                            \
     141    if ((V1->type == 'S') && (V2->vector->type == OPIHI_FLT)) {         \
     142      CopyVector (OUT[0].vector, V2[0].vector);                         \
     143      opihi_flt  M1  =  V1[0].FltValue;                                 \
     144      opihi_flt *M2  =  V2[0].vector[0].elements.Flt;                   \
     145      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     146      for (i = 0; i < Nx; i++, out++, M2++) {                           \
     147        *out = OP;                                                      \
     148      }                                                                 \
     149      break;                                                            \
     150    }                                                                   \
     151    if ((V1->type == 'S') && (V2->vector->type != OPIHI_FLT)) {         \
     152      MatchVector (OUT[0].vector, V2[0].vector, OPIHI_FLT);             \
     153      opihi_flt  M1  =  V1[0].FltValue;                                 \
     154      opihi_int *M2  =  V2[0].vector[0].elements.Int;                   \
     155      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     156      for (i = 0; i < Nx; i++, out++, M2++) {                           \
     157        *out = OP;                                                      \
     158      }                                                                 \
     159      break;                                                            \
     160    }                                                                   \
     161    if ((V1->type == 's') && (V2->vector->type == OPIHI_FLT)) {         \
     162      CopyVector (OUT[0].vector, V2[0].vector);                         \
     163      opihi_int  M1  =  V1[0].IntValue;                                 \
     164      opihi_flt *M2  =  V2[0].vector[0].elements.Flt;                   \
     165      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     166      for (i = 0; i < Nx; i++, out++, M2++) {                           \
     167        *out = OP;                                                      \
     168      }                                                                 \
     169      break;                                                            \
     170    }                                                                   \
     171    if ((FTYPE == 'S') && (V1->type == 's') && (V2->vector->type != OPIHI_FLT)) { \
     172      MatchVector (OUT[0].vector, V2[0].vector, OPIHI_FLT);             \
     173      opihi_int  M1  =  V1[0].IntValue;                                 \
     174      opihi_int *M2  =  V2[0].vector[0].elements.Int;                   \
     175      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     176      for (i = 0; i < Nx; i++, out++, M2++) {                           \
     177        *out = OP;                                                      \
     178      }                                                                 \
     179      break;                                                            \
     180    }                                                                   \
     181    if ((V1->type == 's') && (V2->vector->type != OPIHI_FLT)) {         \
     182      CopyVector (OUT[0].vector, V2[0].vector);                         \
     183      opihi_int  M1  =  V1[0].IntValue;                                 \
     184      opihi_int *M2  =  V2[0].vector[0].elements.Int;                   \
     185      opihi_int *out = OUT[0].vector[0].elements.Int;                   \
     186      for (i = 0; i < Nx; i++, out++, M2++) {                           \
     187        *out = OP;                                                      \
     188      }                                                                 \
     189      break;                                                            \
     190    }                                                                   \
     191  }
     192
     193  switch (op[0]) {
     194    case '+': SV_FUNC('s', M1 + *M2);
     195    case '-': SV_FUNC('s', M1 - *M2);
     196    case '*': SV_FUNC('s', M1 * *M2);
     197    case '/': SV_FUNC('S', M1 / (opihi_flt) *M2);
     198    case '%': SV_FUNC('s', (int) M1 % (int) *M2);
     199    case '^': SV_FUNC('S', pow (M1, *M2));
     200    case '@': SV_FUNC('S', DEG_RAD*atan2 (M1, *M2));
     201    case 'D': SV_FUNC('s', MIN (M1, *M2));
     202    case 'U': SV_FUNC('s', MAX (M1, *M2));
     203    case '<': SV_FUNC('s', (M1 < *M2) ? 1 : 0);
     204    case '>': SV_FUNC('s', (M1 > *M2) ? 1 : 0);
     205    case '&': SV_FUNC('s', ((int)M1 & (int)*M2));
     206    case '|': SV_FUNC('s', ((int)M1 | (int)*M2));
     207    case 'E': SV_FUNC('s', (M1 == *M2) ? 1 : 0);
     208    case 'N': SV_FUNC('s', (M1 != *M2) ? 1 : 0);
     209    case 'L': SV_FUNC('s', (M1 <= *M2) ? 1 : 0);
     210    case 'G': SV_FUNC('s', (M1 >= *M2) ? 1 : 0);
     211    case 'A': SV_FUNC('s', (M1 && *M2) ? 1 : 0);
     212    case 'O': SV_FUNC('s', (M1 || *M2) ? 1 : 0);
     213    default:
     214      sprintf (line, "error: op %c not defined!", op[0]);
     215      push_error (line);
     216      return (FALSE);
     217  }
     218# undef SV_FUNC
     219
     220  /** free up any temporary buffers: **/
     221  if (V2[0].type == 'v') {
     222    free (V2[0].vector[0].elements.Ptr);
     223    free (V2[0].vector);
     224  }
     225
     226  clear_stack (V1);
     227  clear_stack (V2);
     228
     229  /* at the end, V1 and V2 are deleted only if they were temporary */
     230  return (TRUE);
     231
     232}
     233
     234int VS_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
     235
     236  int i, Nx;
    12237  char line[512]; // this is only used to report an error
    13238 
    14239  Nx = V1[0].vector[0].Nelements;
    15   if (Nx != V2[0].vector[0].Nelements) {
    16     return (FALSE);
    17   }
    18 
    19   if (V1[0].type == 'v') {  /** use V1 as temp buffer **/
    20     OUT[0].vector = V1[0].vector;
    21     V1[0].type = 'V'; /* prevent it from being freed below */
    22   } else {
    23     if (V2[0].type == 'v') { /** use V2 as temp buffer, but header of V1 **/
    24       OUT[0].vector = V2[0].vector;
    25       V2[0].type = 'V'; /* prevent it from being freed below */
    26     } else {  /* no spare temp buffer */
    27       OUT[0].vector = InitVector ();
    28       CopyVector (OUT[0].vector, V1[0].vector);
    29     }
    30   }
    31   OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/
    32 
    33   M1  = V1[0].ptr;
    34   M2  = V2[0].ptr;
    35   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     240
     241  OUT[0].vector = InitVector ();
     242  OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
     243
     244  // set up the possible operations : int OP int -> int, all else yield float
     245  // OP is the operation performed on *M1 and *M2
     246# define VS_FUNC(FTYPE,OP) {                                            \
     247    if ((V2->type == 'S') && (V1->vector->type == OPIHI_FLT)) {         \
     248      CopyVector (OUT[0].vector, V1[0].vector);                         \
     249      opihi_flt *M1  =  V1[0].vector[0].elements.Flt;                   \
     250      opihi_flt  M2  =  V2[0].FltValue;                                 \
     251      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     252      for (i = 0; i < Nx; i++, out++, M1++) {                           \
     253        *out = OP;                                                      \
     254      }                                                                 \
     255      break;                                                            \
     256    }                                                                   \
     257    if ((V2->type == 'S') && (V1->vector->type != OPIHI_FLT)) {         \
     258      MatchVector (OUT[0].vector, V1[0].vector, OPIHI_FLT);             \
     259      opihi_int *M1  =  V1[0].vector[0].elements.Int;                   \
     260      opihi_flt  M2  =  V2[0].FltValue;                                 \
     261      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     262      for (i = 0; i < Nx; i++, out++, M1++) {                           \
     263        *out = OP;                                                      \
     264      }                                                                 \
     265      break;                                                            \
     266    }                                                                   \
     267    if ((V2->type == 's') && (V1->vector->type == OPIHI_FLT)) {         \
     268      CopyVector (OUT[0].vector, V1[0].vector);                         \
     269      opihi_flt *M1  =  V1[0].vector[0].elements.Flt;                   \
     270      opihi_int  M2  =  V2[0].IntValue;                                 \
     271      opihi_flt *out = OUT[0].vector[0].elements.Flt;                   \
     272      for (i = 0; i < Nx; i++, out++, M1++) {                           \
     273        *out = OP;                                                      \
     274      }                                                                 \
     275      break;                                                            \
     276    }                                                                   \
     277    if ((FTYPE == 'S') && (V2->type == 's') && (V1->vector->type != OPIHI_FLT)) { \
     278      CopyVector (OUT[0].vector, V1[0].vector);                         \
     279      opihi_int *M1  =  V1[0].vector[0].elements.Int;                   \
     280      opihi_int  M2  =  V2[0].IntValue;                                 \
     281      opihi_int *out = OUT[0].vector[0].elements.Int;                   \
     282      for (i = 0; i < Nx; i++, out++, M1++) {                           \
     283        *out = OP;                                                      \
     284      }                                                                 \
     285      break;                                                            \
     286    }                                                                   \
     287    if ((V2->type == 's') && (V1->vector->type != OPIHI_FLT)) {         \
     288      CopyVector (OUT[0].vector, V1[0].vector);                         \
     289      opihi_int *M1  =  V1[0].vector[0].elements.Int;                   \
     290      opihi_int  M2  =  V2[0].IntValue;                                 \
     291      opihi_int *out = OUT[0].vector[0].elements.Int;                   \
     292      for (i = 0; i < Nx; i++, out++, M1++) {                           \
     293        *out = OP;                                                      \
     294      }                                                                 \
     295      break;                                                            \
     296    }                                                                   \
     297  }
    36298
    37299  switch (op[0]) {
    38   case '+':
    39     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    40       *out = *M1 + *M2;
    41     break;
    42   case '-':
    43     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    44       *out = *M1 - *M2;
    45     break;
    46   case '*':
    47     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    48       *out = *M1 * *M2;
    49     break;
    50   case '/':
    51     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    52       *out = *M1 / *M2;
    53     break;
    54   case '%':
    55     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    56       *out = (int) *M1 % (int) *M2;
    57     break;
    58   case 0x5e:
    59     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    60       *out = pow (*M1, *M2);
    61     break;
    62   case '@':
    63     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    64       *out = DEG_RAD*atan2 (*M1, *M2);
    65     break;
    66   case 'D':
    67     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    68       *out = MIN (*M1, *M2);
    69     break;
    70   case 'U':
    71     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    72       *out = MAX (*M1, *M2);
    73     break;
    74   case '<':
    75     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    76       *out = (*M1 < *M2) ? 1 : 0;
    77     break;
    78   case '>':
    79     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    80       *out = (*M1 > *M2) ? 1 : 0;
    81     break;
    82   case '&':
    83     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    84       *out = ((int)*M1 & (int)*M2);
    85     break;
    86   case '|':
    87     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    88       *out = ((int)*M1 | (int)*M2);
    89     break;
    90   case 'E':
    91     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    92       *out = (*M1 == *M2) ? 1 : 0;
    93     break;
    94   case 'N':
    95     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    96       *out = (*M1 != *M2) ? 1 : 0;
    97     break;
    98   case 'L':
    99     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    100       *out = (*M1 <= *M2) ? 1 : 0;
    101     break;
    102   case 'G':
    103     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    104       *out = (*M1 >= *M2) ? 1 : 0;
    105     break;
    106   case 'A':
    107     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    108       *out = (*M1 && *M2) ? 1 : 0;
    109     break;
    110   case 'O':
    111     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    112       *out = (*M1 || *M2) ? 1 : 0;
    113     break;
    114   default:
    115     sprintf (line, "error: op %c not defined!", op[0]);
    116     push_error (line);
    117     return (FALSE);
    118   }
     300    case '+': VS_FUNC('s', *M1 + M2);
     301    case '-': VS_FUNC('s', *M1 - M2);
     302    case '*': VS_FUNC('s', *M1 * M2);
     303    case '/': VS_FUNC('S', *M1 / (opihi_flt) M2);
     304    case '%': VS_FUNC('s', (int) *M1 % (int) M2);
     305    case '^': VS_FUNC('S', pow (*M1, M2));
     306    case '@': VS_FUNC('S', DEG_RAD*atan2 (*M1, M2));
     307    case 'D': VS_FUNC('s', MIN (*M1, M2));
     308    case 'U': VS_FUNC('s', MAX (*M1, M2));
     309    case '<': VS_FUNC('s', (*M1 < M2) ? 1 : 0);
     310    case '>': VS_FUNC('s', (*M1 > M2) ? 1 : 0);
     311    case '&': VS_FUNC('s', ((int)*M1 & (int)M2));
     312    case '|': VS_FUNC('s', ((int)*M1 | (int)M2));
     313    case 'E': VS_FUNC('s', (*M1 == M2) ? 1 : 0);
     314    case 'N': VS_FUNC('s', (*M1 != M2) ? 1 : 0);
     315    case 'L': VS_FUNC('s', (*M1 <= M2) ? 1 : 0);
     316    case 'G': VS_FUNC('s', (*M1 >= M2) ? 1 : 0);
     317    case 'A': VS_FUNC('s', (*M1 && M2) ? 1 : 0);
     318    case 'O': VS_FUNC('s', (*M1 || M2) ? 1 : 0);
     319    default:
     320      sprintf (line, "error: op %c not defined!", op[0]);
     321      push_error (line);
     322      return (FALSE);
     323  }
     324# undef VS_FUNC
    119325
    120326  /** free up any temporary buffers: **/
    121327
    122328  if (V1[0].type == 'v') {
    123     free (V1[0].vector[0].elements);
     329    free (V1[0].vector[0].elements.Ptr);
    124330    free (V1[0].vector);
    125331  }
    126   if (V2[0].type == 'v') {
    127     free (V2[0].vector[0].elements);
    128     free (V2[0].vector);
    129   }
     332
     333  clear_stack (V1);
     334  clear_stack (V2);
     335
    130336  /* at the end, V1 and V2 are deleted only if they were temporary */
    131 
    132   clear_stack (V1);
    133   clear_stack (V2);
    134   return (TRUE);
    135 
    136 }
    137 
    138 int SV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    139 
    140   int i, Nx;
    141   float *out, *M1, *M2;
    142   char line[512]; // this is only used to report an error
    143  
    144   Nx = V2[0].vector[0].Nelements;
    145 
    146   if (V2[0].type == 'v') { /** use V2 as temp buffer, but header of V1 **/
    147     OUT[0].vector = V2[0].vector;
    148     V2[0].type = 'V'; /* prevent it from being freed below */
    149   } else {  /* no spare temp buffer */
    150     OUT[0].vector = InitVector ();
    151     CopyVector (OUT[0].vector, V2[0].vector);
    152   }
    153   OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
    154 
    155   M1  = V1[0].ptr;
    156   M2  = V2[0].ptr;
    157   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
    158 
    159   switch (op[0]) {
    160   case '+':
    161     for (i = 0; i < Nx; i++, out++, M2++)
    162       *out = *M1 + *M2;
    163     break;
    164   case '-':
    165     for (i = 0; i < Nx; i++, out++, M2++)
    166       *out = *M1 - *M2;
    167     break;
    168   case '*':
    169     for (i = 0; i < Nx; i++, out++, M2++)
    170       *out = *M1 * *M2;
    171     break;
    172   case '/':
    173     for (i = 0; i < Nx; i++, out++, M2++)
    174       *out = *M1 / *M2;
    175     break;
    176   case '%':
    177     for (i = 0; i < Nx; i++, out++, M2++)
    178       *out = (int) *M1 % (int) *M2;
    179     break;
    180   case 0x5e:
    181     for (i = 0; i < Nx; i++, out++, M2++)
    182       *out = pow (*M1, *M2);
    183     break;
    184   case '@':
    185     for (i = 0; i < Nx; i++, out++, M2++)
    186       *out = DEG_RAD*atan2 (*M1, *M2);
    187     break;
    188   case 'D':
    189     for (i = 0; i < Nx; i++, out++, M2++)
    190       *out = MIN (*M1, *M2);
    191     break;
    192   case 'U':
    193     for (i = 0; i < Nx; i++, out++, M2++)
    194       *out = MAX (*M1, *M2);
    195     break;
    196   case '<':
    197     for (i = 0; i < Nx; i++, out++, M2++)
    198       *out = (*M1 < *M2) ? 1 : 0;
    199     break;
    200   case '>':
    201     for (i = 0; i < Nx; i++, out++, M2++)
    202       *out = (*M1 > *M2) ? 1 : 0;
    203     break;
    204   case '&':
    205     for (i = 0; i < Nx; i++, out++, M2++)
    206       *out = ((int)*M1 & (int)*M2);
    207     break;
    208   case '|':
    209     for (i = 0; i < Nx; i++, out++, M2++)
    210       *out = ((int)*M1 | (int)*M2);
    211     break;
    212   case 'E':
    213     for (i = 0; i < Nx; i++, out++, M2++)
    214       *out = (*M1 == *M2) ? 1 : 0;
    215     break;
    216   case 'N':
    217     for (i = 0; i < Nx; i++, out++, M2++)
    218       *out = (*M1 != *M2) ? 1 : 0;
    219     break;
    220   case 'L':
    221     for (i = 0; i < Nx; i++, out++, M2++)
    222       *out = (*M1 <= *M2) ? 1 : 0;
    223     break;
    224   case 'G':
    225     for (i = 0; i < Nx; i++, out++, M2++)
    226       *out = (*M1 >= *M2) ? 1 : 0;
    227     break;
    228   case 'A':
    229     for (i = 0; i < Nx; i++, out++, M2++)
    230       *out = (*M1 && *M2) ? 1 : 0;
    231     break;
    232   case 'O':
    233     for (i = 0; i < Nx; i++, out++, M2++)
    234       *out = (*M1 || *M2) ? 1 : 0;
    235     break;
    236   default:
    237     sprintf (line, "error: op %c not defined!", op[0]);
    238     push_error (line);
    239     return (FALSE);
    240   }
    241 
    242   /** free up any temporary buffers: **/
    243   if (V2[0].type == 'v') {
    244     free (V2[0].vector[0].elements);
    245     free (V2[0].vector);
    246   }
    247 
    248   clear_stack (V1);
    249   clear_stack (V2);
    250 
    251   /* at the end, V1 and V2 are deleted only if they were temporary */
    252   return (TRUE);
    253 
    254 }
    255 
    256 int VS_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    257 
    258   int i, Nx;
    259   float *out, *M1, *M2;
    260   char line[512]; // this is only used to report an error
    261  
    262   Nx = V1[0].vector[0].Nelements;
    263 
    264   if (V1[0].type == 'v') { /** use V1 as temp buffer **/
    265     OUT[0].vector = V1[0].vector;
    266     V1[0].type = 'V'; /* prevent it from being freed below */
    267   } else {  /* no spare temp buffer */
    268     OUT[0].vector = InitVector ();
    269     CopyVector (OUT[0].vector, V1[0].vector);
    270   }
    271   OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
    272 
    273   M1  = V1[0].ptr;
    274   M2  = V2[0].ptr;
    275   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
    276 
    277   switch (op[0]) {
    278   case '+':
    279     for (i = 0; i < Nx; i++, out++, M1++)
    280       *out = *M1 + *M2;
    281     break;
    282   case '-':
    283     for (i = 0; i < Nx; i++, out++, M1++)
    284       *out = *M1 - *M2;
    285     break;
    286   case '*':
    287     for (i = 0; i < Nx; i++, out++, M1++)
    288       *out = *M1 * *M2;
    289     break;
    290   case '/':
    291     for (i = 0; i < Nx; i++, out++, M1++)
    292       *out = *M1 / *M2;
    293     break;
    294   case '%':
    295     for (i = 0; i < Nx; i++, out++, M1++)
    296       *out = (int) *M1 % (int) *M2;
    297     break;
    298   case 0x5e:
    299     for (i = 0; i < Nx; i++, out++, M1++)
    300       *out = pow (*M1, *M2);
    301     break;
    302   case '@':
    303     for (i = 0; i < Nx; i++, out++, M1++)
    304       *out = DEG_RAD*atan2 (*M1, *M2);
    305     break;
    306   case 'D':
    307     for (i = 0; i < Nx; i++, out++, M1++)
    308       *out = MIN (*M1, *M2);
    309     break;
    310   case 'U':
    311     for (i = 0; i < Nx; i++, out++, M1++)
    312       *out = MAX (*M1, *M2);
    313     break;
    314   case '<':
    315     for (i = 0; i < Nx; i++, out++, M1++)
    316       *out = (*M1 < *M2) ? 1 : 0;
    317     break;
    318   case '>':
    319     for (i = 0; i < Nx; i++, out++, M1++)
    320       *out = (*M1 > *M2) ? 1 : 0;
    321     break;
    322   case '&':
    323     for (i = 0; i < Nx; i++, out++, M1++)
    324       *out = ((int)*M1 & (int)*M2);
    325     break;
    326   case '|':
    327     for (i = 0; i < Nx; i++, out++, M1++)
    328       *out = ((int)*M1 | (int)*M2);
    329     break;
    330   case 'E':
    331     for (i = 0; i < Nx; i++, out++, M1++)
    332       *out = (*M1 == *M2) ? 1 : 0;
    333     break;
    334   case 'N':
    335     for (i = 0; i < Nx; i++, out++, M1++)
    336       *out = (*M1 != *M2) ? 1 : 0;
    337     break;
    338   case 'L':
    339     for (i = 0; i < Nx; i++, out++, M1++)
    340       *out = (*M1 <= *M2) ? 1 : 0;
    341     break;
    342   case 'G':
    343     for (i = 0; i < Nx; i++, out++, M1++)
    344       *out = (*M1 >= *M2) ? 1 : 0;
    345     break;
    346   case 'A':
    347     for (i = 0; i < Nx; i++, out++, M1++)
    348       *out = (*M1 && *M2) ? 1 : 0;
    349     break;
    350   case 'O':
    351     for (i = 0; i < Nx; i++, out++, M1++)
    352       *out = (*M1 || *M2) ? 1 : 0;
    353     break;
    354   default:
    355     sprintf (line, "error: op %c not defined!", op[0]);
    356     push_error (line);
    357     return (FALSE);
    358   }
    359 
    360   /** free up any temporary buffers: **/
    361 
    362   if (V1[0].type == 'v') {
    363     free (V1[0].vector[0].elements);
    364     free (V1[0].vector);
    365   }
    366 
    367   clear_stack (V1);
    368   clear_stack (V2);
    369 
    370   /* at the end, V1 and V2 are deleted only if they were temporary */
    371   return (TRUE);
    372 
    373 }
    374 
     337  return (TRUE);
     338
     339}
     340
     341// the vector is applied to each column
    375342int MV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    376343
    377344  int i, j, Nx, Ny;
    378   float *out, *M1, *M2;
    379345  char line[512]; // this is only used to report an error
    380346 
    … …  
    397363  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    398364
    399   M1  = V1[0].ptr;
    400   M2  = V2[0].ptr;
    401   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     365  float     *M1  = (float *) V1[0].buffer[0].matrix.buffer;
     366  float     *out = (float *)OUT[0].buffer[0].matrix.buffer;
     367
     368# define MV_FUNC(OP) {                                  \
     369    if (V2->vector->type == OPIHI_FLT) {                \
     370      opihi_flt *M2  =  V2[0].vector[0].elements.Flt;   \
     371      for (i = 0; i < Ny; i++, M2++) {                  \
     372        for (j = 0; j < Nx; j++, out++, M1++) {         \
     373          *out = OP;                                    \
     374        }                                               \
     375      }                                                 \
     376      break;                                            \
     377    }                                                   \
     378    if (V2->vector->type != OPIHI_FLT) {                \
     379      opihi_int *M2  =  V2[0].vector[0].elements.Int;   \
     380      for (i = 0; i < Ny; i++, M2++) {                  \
     381        for (j = 0; j < Nx; j++, out++, M1++) {         \
     382          *out = OP;                                    \
     383        }                                               \
     384      }                                                 \
     385      break;                                            \
     386    }                                                   \
     387  }
    402388
    403389  switch (op[0]) {
    404   case '+':
    405     for (i = 0; i < Ny; i++, M2++) {
    406       for (j = 0; j < Nx; j++, out++, M1++)
    407         *out = *M1 + *M2;
    408     }
    409     break;
    410   case '-':
    411     for (i = 0; i < Ny; i++, M2++) {
    412       for (j = 0; j < Nx; j++, out++, M1++)
    413         *out = *M1 - *M2;
    414     }
    415     break;
    416   case '*':
    417     for (i = 0; i < Ny; i++, M2++) {
    418       for (j = 0; j < Nx; j++, out++, M1++)
    419         *out = *M1 * *M2;
    420     }
    421     break;
    422   case '/':
    423     for (i = 0; i < Ny; i++, M2++) {
    424       for (j = 0; j < Nx; j++, out++, M1++)
    425         *out = *M1 / *M2;
    426     }
    427     break;
    428   case '%':
    429     for (i = 0; i < Ny; i++, M2++) {
    430       for (j = 0; j < Nx; j++, out++, M1++)
    431         *out = (int) *M1 % (int) *M2;
    432     }
    433     break;
    434   case 0x5e:
    435     for (i = 0; i < Ny; i++, M2++) {
    436       for (j = 0; j < Nx; j++, out++, M1++)
    437         *out = pow (*M1, *M2);
    438     }
    439     break;
    440   case '@':
    441     for (i = 0; i < Ny; i++, M2++) {
    442       for (j = 0; j < Nx; j++, out++, M1++)
    443         *out = DEG_RAD*atan2 (*M1, *M2);
    444     }
    445     break;
    446   case 'D':
    447     for (i = 0; i < Ny; i++, M2++) {
    448       for (j = 0; j < Nx; j++, out++, M1++)
    449         *out = MIN (*M1, *M2);
    450     }
    451     break;
    452   case 'U':
    453     for (i = 0; i < Ny; i++, M2++) {
    454       for (j = 0; j < Nx; j++, out++, M1++)
    455         *out = MAX (*M1, *M2);
    456     }
    457     break;
    458   case '<':
    459     for (i = 0; i < Ny; i++, M2++) {
    460       for (j = 0; j < Nx; j++, out++, M1++)
    461         *out = (*M1 < *M2) ? 1 : 0;
    462     }
    463     break;
    464   case '>':
    465     for (i = 0; i < Ny; i++, M2++) {
    466       for (j = 0; j < Nx; j++, out++, M1++)
    467         *out = (*M1 > *M2) ? 1 : 0;
    468     }
    469     break;
    470   case '&':
    471     for (i = 0; i < Ny; i++, M2++) {
    472       for (j = 0; j < Nx; j++, out++, M1++)
    473         *out = ((int)*M1 & (int)*M2);
    474     }
    475     break;
    476   case '|':
    477     for (i = 0; i < Ny; i++, M2++) {
    478       for (j = 0; j < Nx; j++, out++, M1++)
    479         *out = ((int)*M1 | (int)*M2);
    480     }
    481     break;
    482   case 'E':
    483     for (i = 0; i < Ny; i++, M2++) {
    484       for (j = 0; j < Nx; j++, out++, M1++)
    485         *out = (*M1 == *M2) ? 1 : 0;
    486     }
    487     break;
    488   case 'N':
    489     for (i = 0; i < Ny; i++, M2++) {
    490       for (j = 0; j < Nx; j++, out++, M1++)
    491         *out = (*M1 != *M2) ? 1 : 0;
    492     }
    493     break;
    494   case 'L':
    495     for (i = 0; i < Ny; i++, M2++) {
    496       for (j = 0; j < Nx; j++, out++, M1++)
    497         *out = (*M1 <= *M2) ? 1 : 0;
    498     }
    499     break;
    500   case 'G':
    501     for (i = 0; i < Ny; i++, M2++) {
    502       for (j = 0; j < Nx; j++, out++, M1++)
    503         *out = (*M1 >= *M2) ? 1 : 0;
    504     }
    505     break;
    506   case 'A':
    507     for (i = 0; i < Ny; i++, M2++) {
    508       for (j = 0; j < Nx; j++, out++, M1++)
    509         *out = (*M1 && *M2) ? 1 : 0;
    510     }
    511     break;
    512   case 'O':
    513     for (i = 0; i < Ny; i++, M2++) {
    514       for (j = 0; j < Nx; j++, out++, M1++)
    515         *out = (*M1 || *M2) ? 1 : 0;
    516     }
    517     break;
    518   default:
    519     sprintf (line, "error: op %c not defined!", op[0]);
    520     push_error (line);
    521     return (FALSE);
    522   }
     390    case '+': MV_FUNC(*M1 + *M2);
     391    case '-': MV_FUNC(*M1 - *M2);
     392    case '*': MV_FUNC(*M1 * *M2);
     393    case '/': MV_FUNC(*M1 / (opihi_flt) *M2);
     394    case '%': MV_FUNC((int) *M1 % (int) *M2);
     395    case '^': MV_FUNC(pow (*M1, *M2));
     396    case '@': MV_FUNC(DEG_RAD*atan2 (*M1, *M2));
     397    case 'D': MV_FUNC(MIN (*M1, *M2));
     398    case 'U': MV_FUNC(MAX (*M1, *M2));
     399    case '<': MV_FUNC((*M1 < *M2) ? 1 : 0);
     400    case '>': MV_FUNC((*M1 > *M2) ? 1 : 0);
     401    case '&': MV_FUNC(((int)*M1 & (int)*M2));
     402    case '|': MV_FUNC(((int)*M1 | (int)*M2));
     403    case 'E': MV_FUNC((*M1 == *M2) ? 1 : 0);
     404    case 'N': MV_FUNC((*M1 != *M2) ? 1 : 0);
     405    case 'L': MV_FUNC((*M1 <= *M2) ? 1 : 0);
     406    case 'G': MV_FUNC((*M1 >= *M2) ? 1 : 0);
     407    case 'A': MV_FUNC((*M1 && *M2) ? 1 : 0);
     408    case 'O': MV_FUNC((*M1 || *M2) ? 1 : 0);
     409    default:
     410      sprintf (line, "error: op %c not defined!", op[0]);
     411      push_error (line);
     412      return (FALSE);
     413  }
     414# undef MV_FUNC
    523415
    524416  /** free up any temporary buffers: **/
    … …  
    530422  }
    531423  if (V2[0].type == 'v') {
    532     free (V2[0].vector[0].elements);
     424    free (V2[0].vector[0].elements.Ptr);
    533425    free (V2[0].vector);
    534426  }
    … …  
    539431  /* at the end, V1 and V2 are deleted only if they were temporary */
    540432  return (TRUE);
    541 
    542 }
    543 
    544 
     433}
     434
     435// the vector is applied to each row
    545436int VM_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    546437
    547438  int i, j, Nx, Ny;
    548   float *out, *M1, *M2;
    549439  char line[512]; // this is only used to report an error
    550440 
    … …  
    565455  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    566456
    567   M1  = V1[0].ptr;
    568   M2  = V2[0].ptr;
    569   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     457  float     *M2  = (float *) V2[0].buffer[0].matrix.buffer;
     458  float     *out = (float *)OUT[0].buffer[0].matrix.buffer;
     459
     460# define VM_FUNC(OP) {                                  \
     461    if (V1->vector->type == OPIHI_FLT) {                \
     462      for (i = 0; i < Ny; i++) {                        \
     463        opihi_flt *M1  = V1[0].vector[0].elements.Flt;  \
     464        for (j = 0; j < Nx; j++, out++, M1++, M2++) {   \
     465          *out = OP;                                    \
     466        }                                               \
     467      }                                                 \
     468      break;                                            \
     469    }                                                   \
     470    if (V1->vector->type != OPIHI_FLT) {                \
     471      for (i = 0; i < Ny; i++) {                        \
     472        opihi_int *M1  =  V1[0].vector[0].elements.Int; \
     473        for (j = 0; j < Nx; j++, out++, M1++, M2++) {   \
     474          *out = OP;                                    \
     475        }                                               \
     476      }                                                 \
     477      break;                                            \
     478    }                                                   \
     479  }
    570480
    571481  switch (op[0]) {
    572   case '+':
    573     for (i = 0; i < Ny; i++) {
    574       M1 = V1[0].ptr;
    575       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    576         *out = *M1 + *M2;
    577     }
    578     break;
    579   case '-':
    580     for (i = 0; i < Ny; i++) {
    581       M1 = V1[0].ptr;
    582       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    583         *out = *M1 - *M2;
    584     }
    585     break;
    586   case '*':
    587     for (i = 0; i < Ny; i++) {
    588       M1 = V1[0].ptr;
    589       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    590         *out = *M1 * *M2;
    591     }
    592     break;
    593   case '/':
    594     for (i = 0; i < Ny; i++) {
    595       M1 = V1[0].ptr;
    596       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    597         *out = *M1 / *M2;
    598     }
    599     break;
    600   case '%':
    601     for (i = 0; i < Ny; i++) {
    602       M1 = V1[0].ptr;
    603       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    604         *out = (int) *M1 % (int) *M2;
    605     }
    606     break;
    607   case 0x5e:
    608     for (i = 0; i < Ny; i++) {
    609       M1 = V1[0].ptr;
    610       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    611         *out = pow (*M1, *M2);
    612     }
    613     break;
    614   case '@':
    615     for (i = 0; i < Ny; i++) {
    616       M1 = V1[0].ptr;
    617       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    618         *out = DEG_RAD*atan2 (*M1, *M2);
    619     }
    620     break;
    621   case 'D':
    622     for (i = 0; i < Ny; i++) {
    623       M1 = V1[0].ptr;
    624       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    625         *out = MIN (*M1, *M2);
    626     }
    627     break;
    628   case 'U':
    629     for (i = 0; i < Ny; i++) {
    630       M1 = V1[0].ptr;
    631       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    632         *out = MAX (*M1, *M2);
    633     }
    634     break;
    635   case '<':
    636     for (i = 0; i < Ny; i++) {
    637       M1 = V1[0].ptr;
    638       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    639         *out = (*M1 < *M2) ? 1 : 0;
    640     }
    641     break;
    642   case '>':
    643     for (i = 0; i < Ny; i++) {
    644       M1 = V1[0].ptr;
    645       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    646         *out = (*M1 > *M2) ? 1 : 0;
    647     }
    648     break;
    649   case '&':
    650     for (i = 0; i < Ny; i++) {
    651       M1 = V1[0].ptr;
    652       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    653         *out = ((int)*M1 & (int)*M2);
    654     }
    655     break;
    656   case '|':
    657     for (i = 0; i < Ny; i++) {
    658       M1 = V1[0].ptr;
    659       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    660         *out = ((int)*M1 | (int)*M2);
    661     }
    662     break;
    663   case 'E':
    664     for (i = 0; i < Ny; i++) {
    665       M1 = V1[0].ptr;
    666       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    667         *out = (*M1 == *M2) ? 1 : 0;
    668     }
    669     break;
    670   case 'N':
    671     for (i = 0; i < Ny; i++) {
    672       M1 = V1[0].ptr;
    673       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    674         *out = (*M1 != *M2) ? 1 : 0;
    675     }
    676     break;
    677   case 'L':
    678     for (i = 0; i < Ny; i++) {
    679       M1 = V1[0].ptr;
    680       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    681         *out = (*M1 <= *M2) ? 1 : 0;
    682     }
    683     break;
    684   case 'G':
    685     for (i = 0; i < Ny; i++) {
    686       M1 = V1[0].ptr;
    687       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    688         *out = (*M1 >= *M2) ? 1 : 0;
    689     }
    690     break;
    691   case 'A':
    692     for (i = 0; i < Ny; i++) {
    693       M1 = V1[0].ptr;
    694       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    695         *out = (*M1 && *M2) ? 1 : 0;
    696     }
    697     break;
    698   case 'O':
    699     for (i = 0; i < Ny; i++) {
    700       M1 = V1[0].ptr;
    701       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    702         *out = (*M1 || *M2) ? 1 : 0;
    703     }
    704     break;
    705   default:
    706     sprintf (line, "error: op %c not defined!", op[0]);
    707     push_error (line);
    708     return (FALSE);
    709   }
     482    case '+': VM_FUNC(*M1 + *M2);
     483    case '-': VM_FUNC(*M1 - *M2);
     484    case '*': VM_FUNC(*M1 * *M2);
     485    case '/': VM_FUNC(*M1 / (opihi_flt) *M2);
     486    case '%': VM_FUNC((int) *M1 % (int) *M2);
     487    case '^': VM_FUNC(pow (*M1, *M2));
     488    case '@': VM_FUNC(DEG_RAD*atan2 (*M1, *M2));
     489    case 'D': VM_FUNC(MIN (*M1, *M2));
     490    case 'U': VM_FUNC(MAX (*M1, *M2));
     491    case '<': VM_FUNC((*M1 < *M2) ? 1 : 0);
     492    case '>': VM_FUNC((*M1 > *M2) ? 1 : 0);
     493    case '&': VM_FUNC(((int)*M1 & (int)*M2));
     494    case '|': VM_FUNC(((int)*M1 | (int)*M2));
     495    case 'E': VM_FUNC((*M1 == *M2) ? 1 : 0);
     496    case 'N': VM_FUNC((*M1 != *M2) ? 1 : 0);
     497    case 'L': VM_FUNC((*M1 <= *M2) ? 1 : 0);
     498    case 'G': VM_FUNC((*M1 >= *M2) ? 1 : 0);
     499    case 'A': VM_FUNC((*M1 && *M2) ? 1 : 0);
     500    case 'O': VM_FUNC((*M1 || *M2) ? 1 : 0);
     501    default:
     502      sprintf (line, "error: op %c not defined!", op[0]);
     503      push_error (line);
     504      return (FALSE);
     505  }
     506# undef VM_FUNC
    710507
    711508  /** free up any temporary buffers: **/
    712509
    713510  if (V1[0].type == 'v') {
    714     free (V1[0].vector[0].elements);
     511    free (V1[0].vector[0].elements.Ptr);
    715512    free (V1[0].vector);
    716513  }
    … …  
    752549  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    753550
    754   M1  = V1[0].ptr;
    755   M2  = V2[0].ptr;
    756   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     551  M1  = (float *)V1[0].buffer[0].matrix.buffer;
     552  M2  = (float *)V2[0].buffer[0].matrix.buffer;
     553  out = (float *)OUT[0].buffer[0].matrix.buffer;
     554
     555# define MM_FUNC(OP)                                    \
     556  for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++) {      \
     557    *out = OP;                                          \
     558  }                                                     \
     559  break;
    757560
    758561  switch (op[0]) {
    759   case '+':
    760     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    761       *out = *M1 + *M2;
    762     break;
    763   case '-':
    764     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    765       *out = *M1 - *M2;
    766     break;
    767   case '*':
    768     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    769       *out = *M1 * *M2;
    770     break;
    771   case '/':
    772     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    773       *out = *M1 / *M2;
    774     break;
    775   case '%':
    776     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    777       *out = (int) *M1 % (int) *M2;
    778     break;
    779   case 0x5e:
    780     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    781       *out = pow (*M1, *M2);
    782     break;
    783   case '@':
    784     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    785       *out = DEG_RAD*atan2 (*M1, *M2);
    786     break;
    787   case 'D':
    788     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    789       *out = MIN (*M1, *M2);
    790     break;
    791   case 'U':
    792     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    793       *out = MAX (*M1, *M2);
    794     break;
    795   case '<':
    796     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    797       *out = (*M1 < *M2) ? 1 : 0;
    798     break;
    799   case '>':
    800     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    801       *out = (*M1 > *M2) ? 1 : 0;
    802     break;
    803   case '&':
    804     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    805       *out = ((int)*M1 & (int)*M2);
    806     break;
    807   case '|':
    808     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    809       *out = ((int)*M1 | (int)*M2);
    810     break;
    811   case 'E':
    812     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    813       *out = (*M1 == *M2) ? 1 : 0;
    814     break;
    815   case 'N':
    816     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    817       *out = (*M1 != *M2) ? 1 : 0;
    818     break;
    819   case 'L':
    820     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    821       *out = (*M1 <= *M2) ? 1 : 0;
    822     break;
    823   case 'G':
    824     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    825       *out = (*M1 >= *M2) ? 1 : 0;
    826     break;
    827   case 'A':
    828     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    829       *out = (*M1 && *M2) ? 1 : 0;
    830     break;
    831   case 'O':
    832     for (i = 0; i < Nx*Ny; i++, out++, M1++, M2++)
    833       *out = (*M1 || *M2) ? 1 : 0;
    834     break;
    835   default:
    836     sprintf (line, "error: op %c not defined!", op[0]);
    837     push_error (line);
    838     return (FALSE);
    839   }
     562    case '+': MM_FUNC(*M1 + *M2);
     563    case '-': MM_FUNC(*M1 - *M2);
     564    case '*': MM_FUNC(*M1 * *M2);
     565    case '/': MM_FUNC(*M1 / (float) *M2);
     566    case '%': MM_FUNC((int) *M1 % (int) *M2);
     567    case '^': MM_FUNC(pow (*M1, *M2));
     568    case '@': MM_FUNC(DEG_RAD*atan2 (*M1, *M2));
     569    case 'D': MM_FUNC(MIN (*M1, *M2));
     570    case 'U': MM_FUNC(MAX (*M1, *M2));
     571    case '<': MM_FUNC((*M1 < *M2) ? 1 : 0);
     572    case '>': MM_FUNC((*M1 > *M2) ? 1 : 0);
     573    case '&': MM_FUNC(((int)*M1 & (int)*M2));
     574    case '|': MM_FUNC(((int)*M1 | (int)*M2));
     575    case 'E': MM_FUNC((*M1 == *M2) ? 1 : 0);
     576    case 'N': MM_FUNC((*M1 != *M2) ? 1 : 0);
     577    case 'L': MM_FUNC((*M1 <= *M2) ? 1 : 0);
     578    case 'G': MM_FUNC((*M1 >= *M2) ? 1 : 0);
     579    case 'A': MM_FUNC((*M1 && *M2) ? 1 : 0);
     580    case 'O': MM_FUNC((*M1 || *M2) ? 1 : 0);
     581    default:
     582      sprintf (line, "error: op %c not defined!", op[0]);
     583      push_error (line);
     584      return (FALSE);
     585  }
     586# undef MM_FUNC
    840587
    841588  /** free up any temporary buffers: **/
    … …  
    857604  /* at the end, V1 and V2 are deleted only if they were temporary */
    858605  return (TRUE);
    859 
    860 }
    861 
     606}
    862607
    863608int MS_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    864609
    865610  int i, Nx, Ny;
    866   float *out, *M1, *M2;
    867611  char line[512]; // this is only used to report an error
    868612 
    … …  
    880624  OUT[0].type = 'm';      /*** <<--- says this is a temporary matrix ***/
    881625
    882   M1  = V1[0].ptr;
    883   M2  = V2[0].ptr;
    884   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     626  float *M1    = (float *)V1[0].buffer[0].matrix.buffer;
     627  float *out   = (float *)OUT[0].buffer[0].matrix.buffer;
     628
     629# define MS_FUNC(OP) {                                  \
     630    if (V2->type == 's')  {                             \
     631      opihi_flt M2 = V2[0].FltValue;                    \
     632      for (i = 0; i < Nx*Ny; i++, out++, M1++) {        \
     633        *out = OP;                                      \
     634      }                                                 \
     635      break;                                            \
     636    }                                                   \
     637    if (V2->type == 'S')  {                             \
     638      opihi_int M2 = V2[0].IntValue;                    \
     639      for (i = 0; i < Nx*Ny; i++, out++, M1++) {        \
     640        *out = OP;                                      \
     641      }                                                 \
     642      break;                                            \
     643    }                                                   \
     644  }
    885645
    886646  switch (op[0]) {
    887   case '+':
    888     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    889       *out = *M1 + *M2;
    890     break;
    891   case '-':
    892     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    893       *out = *M1 - *M2;
    894     break;
    895   case '*':
    896     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    897       *out = *M1 * *M2;
    898     break;
    899   case '/':
    900     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    901       *out = *M1 / *M2;
    902     break;
    903   case '%':
    904     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    905       *out = (int) *M1 % (int) *M2;
    906     break;
    907   case 0x5e:
    908     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    909       *out = pow (*M1, *M2);
    910     break;
    911   case '@':
    912     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    913       *out = DEG_RAD*atan2 (*M1, *M2);
    914     break;
    915   case 'D':
    916     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    917       *out = MIN (*M1, *M2);
    918     break;
    919   case 'U':
    920     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    921       *out = MAX (*M1, *M2);
    922     break;
    923   case '<':
    924     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    925       *out = (*M1 < *M2) ? 1 : 0;
    926     break;
    927   case '>':
    928     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    929       *out = (*M1 > *M2) ? 1 : 0;
    930     break;
    931   case '&':
    932     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    933       *out = ((int)*M1 & (int)*M2);
    934     break;
    935   case '|':
    936     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    937       *out = ((int)*M1 | (int)*M2);
    938     break;
    939   case 'E':
    940     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    941       *out = (*M1 == *M2) ? 1 : 0;
    942     break;
    943   case 'N':
    944     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    945       *out = (*M1 != *M2) ? 1 : 0;
    946     break;
    947   case 'L':
    948     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    949       *out = (*M1 <= *M2) ? 1 : 0;
    950     break;
    951   case 'G':
    952     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    953       *out = (*M1 >= *M2) ? 1 : 0;
    954     break;
    955   case 'A':
    956     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    957       *out = (*M1 && *M2) ? 1 : 0;
    958     break;
    959   case 'O':
    960     for (i = 0; i < Nx*Ny; i++, out++, M1++)
    961       *out = (*M1 || *M2) ? 1 : 0;
    962     break;
    963   default:
    964     sprintf (line, "error: op %c not defined!", op[0]);
    965     push_error (line);
    966     return (FALSE);
    967   }
     647    case '+': MS_FUNC(*M1 + M2);
     648    case '-': MS_FUNC(*M1 - M2);
     649    case '*': MS_FUNC(*M1 * M2);
     650    case '/': MS_FUNC(*M1 / (float) M2);
     651    case '%': MS_FUNC((int) *M1 % (int) M2);
     652    case '^': MS_FUNC(pow (*M1, M2));
     653    case '@': MS_FUNC(DEG_RAD*atan2 (*M1, M2));
     654    case 'D': MS_FUNC(MIN (*M1, M2));
     655    case 'U': MS_FUNC(MAX (*M1, M2));
     656    case '<': MS_FUNC((*M1 < M2) ? 1 : 0);
     657    case '>': MS_FUNC((*M1 > M2) ? 1 : 0);
     658    case '&': MS_FUNC(((int)*M1 & (int)M2));
     659    case '|': MS_FUNC(((int)*M1 | (int)M2));
     660    case 'E': MS_FUNC((*M1 == M2) ? 1 : 0);
     661    case 'N': MS_FUNC((*M1 != M2) ? 1 : 0);
     662    case 'L': MS_FUNC((*M1 <= M2) ? 1 : 0);
     663    case 'G': MS_FUNC((*M1 >= M2) ? 1 : 0);
     664    case 'A': MS_FUNC((*M1 && M2) ? 1 : 0);
     665    case 'O': MS_FUNC((*M1 || M2) ? 1 : 0);
     666    default:
     667      sprintf (line, "error: op %c not defined!", op[0]);
     668      push_error (line);
     669      return (FALSE);
     670  }
     671# undef MS_FUNC
    968672
    969673  if (V1[0].type == 'm') {
    … …  
    976680
    977681  return (TRUE);
    978 
    979682}
    980683
    … …  
    983686
    984687  int i, Nx, Ny;
    985   float *out, *M1, *M2;
    986688  char line[512]; // this is only used to report an error
    987689 
    … …  
    998700  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    999701
    1000   M1  = V1[0].ptr;
    1001   M2  = V2[0].ptr;
    1002   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     702  float *M2    = (float *)V2[0].buffer[0].matrix.buffer;
     703  float *out   = (float *)OUT[0].buffer[0].matrix.buffer;
     704
     705# define SM_FUNC(OP) {                                  \
     706    if (V1->type == 's')  {                             \
     707      opihi_flt M1 = V1[0].FltValue;                    \
     708      for (i = 0; i < Nx*Ny; i++, out++, M2++) {        \
     709        *out = OP;                                      \
     710      }                                                 \
     711      break;                                            \
     712    }                                                   \
     713    if (V1->type == 'S')  {                             \
     714      opihi_int M1 = V1[0].IntValue;                    \
     715      for (i = 0; i < Nx*Ny; i++, out++, M2++) {        \
     716        *out = OP;                                      \
     717      }                                                 \
     718      break;                                            \
     719    }                                                   \
     720  }
    1003721
    1004722  switch (op[0]) {
    1005   case '+':
    1006     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1007       *out = *M1 + *M2;
    1008     break;
    1009   case '-':
    1010     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1011       *out = *M1 - *M2;
    1012     break;
    1013   case '*':
    1014     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1015       *out = *M1 * *M2;
    1016     break;
    1017   case '/':
    1018     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1019       *out = *M1 / *M2;
    1020     break;
    1021   case '%':
    1022     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1023       *out = (int) *M1 % (int) *M2;
    1024     break;
    1025   case 0x5e:
    1026     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1027       *out = pow (*M1, *M2);
    1028     break;
    1029   case '@':
    1030     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1031       *out = DEG_RAD*atan2 (*M1, *M2);
    1032     break;
    1033   case 'D':
    1034     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1035       *out = MIN (*M1, *M2);
    1036     break;
    1037   case 'U':
    1038     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1039       *out = MAX (*M1, *M2);
    1040     break;
    1041   case '<':
    1042     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1043       *out = (*M1 < *M2) ? 1 : 0;
    1044     break;
    1045   case '>':
    1046     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1047       *out = (*M1 > *M2) ? 1 : 0;
    1048     break;
    1049   case '&':
    1050     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1051       *out = ((int)*M1 & (int)*M2);
    1052     break;
    1053   case '|':
    1054     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1055       *out = ((int)*M1 | (int)*M2);
    1056     break;
    1057   case 'E':
    1058     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1059       *out = (*M1 == *M2) ? 1 : 0;
    1060     break;
    1061   case 'N':
    1062     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1063       *out = (*M1 != *M2) ? 1 : 0;
    1064     break;
    1065   case 'L':
    1066     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1067       *out = (*M1 <= *M2) ? 1 : 0;
    1068     break;
    1069   case 'G':
    1070     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1071       *out = (*M1 >= *M2) ? 1 : 0;
    1072     break;
    1073   case 'A':
    1074     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1075       *out = (*M1 && *M2) ? 1 : 0;
    1076     break;
    1077   case 'O':
    1078     for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1079       *out = (*M1 || *M2) ? 1 : 0;
    1080     break;
    1081   default:
    1082     sprintf (line, "error: op %c not defined!", op[0]);
    1083     push_error (line);
    1084     return (FALSE);
    1085   }
     723    case '+': SM_FUNC(M1 + *M2);
     724    case '-': SM_FUNC(M1 - *M2);
     725    case '*': SM_FUNC(M1 * *M2);
     726    case '/': SM_FUNC(M1 / (float) *M2);
     727    case '%': SM_FUNC((int) M1 % (int) *M2);
     728    case '^': SM_FUNC(pow (M1, *M2));
     729    case '@': SM_FUNC(DEG_RAD*atan2 (M1, *M2));
     730    case 'D': SM_FUNC(MIN (M1, *M2));
     731    case 'U': SM_FUNC(MAX (M1, *M2));
     732    case '<': SM_FUNC((M1 < *M2) ? 1 : 0);
     733    case '>': SM_FUNC((M1 > *M2) ? 1 : 0);
     734    case '&': SM_FUNC(((int)M1 & (int)*M2));
     735    case '|': SM_FUNC(((int)M1 | (int)*M2));
     736    case 'E': SM_FUNC((M1 == *M2) ? 1 : 0);
     737    case 'N': SM_FUNC((M1 != *M2) ? 1 : 0);
     738    case 'L': SM_FUNC((M1 <= *M2) ? 1 : 0);
     739    case 'G': SM_FUNC((M1 >= *M2) ? 1 : 0);
     740    case 'A': SM_FUNC((M1 && *M2) ? 1 : 0);
     741    case 'O': SM_FUNC((M1 || *M2) ? 1 : 0);
     742    default:
     743      sprintf (line, "error: op %c not defined!", op[0]);
     744      push_error (line);
     745      return (FALSE);
     746  }
     747# undef SM_FUNC
    1086748
    1087749  if (V2[0].type == 'm') {
    … …  
    1097759}
    1098760
    1099 
    1100761int SS_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    1101762
    1102   float *M1, *M2, *out;
    1103763  char line[512]; // this is only used to report an error
    1104764
    1105   M1  = V1[0].ptr;
    1106   M2  = V2[0].ptr;
    1107   OUT[0].ptr = V1[0].ptr;
    1108   out = OUT[0].ptr;
    1109 
     765# define SS_FUNC(FTYPE,OP) {                                            \
     766    if ((V1->type == 'S') && (V2->type == 'S')) {                       \
     767      opihi_flt M1 = V1[0].FltValue;                                    \
     768      opihi_flt M2 = V2[0].FltValue;                                    \
     769      OUT[0].type = 'S';                                                \
     770      OUT[0].FltValue = OP;                                             \
     771      break;                                                            \
     772    }                                                                   \
     773    if ((V1->type == 'S') && (V2->type == 's')) {                       \
     774      opihi_flt M1 = V1[0].FltValue;                                    \
     775      opihi_int M2 = V2[0].IntValue;                                    \
     776      OUT[0].type = 'S';                                                \
     777      OUT[0].FltValue = OP;                                             \
     778      break;                                                            \
     779    }                                                                   \
     780    if ((V1->type == 's') && (V2->type == 'S')) {                       \
     781      opihi_int M1 = V1[0].IntValue;                                    \
     782      opihi_flt M2 = V2[0].FltValue;                                    \
     783      OUT[0].type = 'S';                                                \
     784      OUT[0].FltValue = OP;                                             \
     785      break;                                                            \
     786    }                                                                   \
     787    if ((FTYPE == 'S') && (V1->type == 's') && (V2->type == 's')) {     \
     788      opihi_int M1 = V1[0].IntValue;                                    \
     789      opihi_int M2 = V2[0].IntValue;                                    \
     790      OUT[0].type = 'S';                                                \
     791      OUT[0].FltValue = OP;                                             \
     792      break;                                                            \
     793    }                                                                   \
     794    if ((V1->type == 's') && (V2->type == 's')) {                       \
     795      opihi_int M1 = V1[0].IntValue;                                    \
     796      opihi_int M2 = V2[0].IntValue;                                    \
     797      OUT[0].type = 's';                                                \
     798      OUT[0].IntValue = OP;                                             \
     799      break;                                                            \
     800    }                                                                   \
     801  }
    1110802
    1111803  switch (op[0]) {
    1112   case '+':
    1113     *out = *M1 + *M2;
    1114     break;   
    1115   case '-':
    1116     *out = *M1 - *M2;
    1117     break;   
    1118   case '*':
    1119     *out = *M1 * *M2;
    1120     break;   
    1121   case '/':
    1122     *out = *M1 / *M2;
    1123     break;
    1124   case '%':
    1125     *out = (int) *M1 % (int) *M2;
    1126     break;
    1127   case 0x5e:
    1128     *out = pow (*M1, *M2);
    1129     break;
    1130   case '@':
    1131     *out = DEG_RAD*atan2 (*M1, *M2);
    1132     break;
    1133   case 'D':
    1134     *out = MIN (*M1, *M2);
    1135     break;
    1136   case 'U':
    1137     *out = MAX (*M1, *M2);
    1138     break;
    1139   case '<':
    1140     *out = (*M1 < *M2) ? 1 : 0;
    1141     break;
    1142   case '>':
    1143     *out = (*M1 > *M2) ? 1 : 0;
    1144     break;
    1145   case '&':
    1146     *out = ((int)*M1 & (int)*M2);
    1147     break;
    1148   case '|':
    1149     *out = ((int)*M1 | (int)*M2);
    1150     break;
    1151   case 'E':
    1152     *out = (*M1 == *M2) ? 1 : 0;
    1153     break;
    1154   case 'N':
    1155     *out = (*M1 != *M2) ? 1 : 0;
    1156     break;
    1157   case 'L':
    1158     *out = (*M1 <= *M2) ? 1 : 0;
    1159     break;
    1160   case 'G':
    1161     *out = (*M1 >= *M2) ? 1 : 0;
    1162     break;
    1163   case 'A':
    1164     *out = (*M1 && *M2) ? 1 : 0;
    1165     break;
    1166   case 'O':
    1167     *out = (*M1 || *M2) ? 1 : 0;
    1168     break;
    1169   default:
    1170     sprintf (line, "error: op %c not defined!", op[0]);
    1171     push_error (line);
    1172     return (FALSE);
    1173   }
    1174   OUT[0].Float = *(OUT[0].ptr);
    1175   OUT[0].type = 'S';
     804    case '+': SS_FUNC('s', M1 + M2);
     805    case '-': SS_FUNC('s', M1 - M2);
     806    case '*': SS_FUNC('s', M1 * M2);
     807    case '/': SS_FUNC('S', M1 / (opihi_flt) M2);
     808    case '%': SS_FUNC('s', (int) M1 % (int) M2);
     809    case '^': SS_FUNC('S', pow (M1, M2));
     810    case '@': SS_FUNC('S', DEG_RAD*atan2 (M1, M2));
     811    case 'D': SS_FUNC('s', MIN (M1, M2));
     812    case 'U': SS_FUNC('s', MAX (M1, M2));
     813    case '<': SS_FUNC('s', (M1 < M2) ? 1 : 0);
     814    case '>': SS_FUNC('s', (M1 > M2) ? 1 : 0);
     815    case '&': SS_FUNC('s', ((int)M1 & (int)M2));
     816    case '|': SS_FUNC('s', ((int)M1 | (int)M2));
     817    case 'E': SS_FUNC('s', (M1 == M2) ? 1 : 0);
     818    case 'N': SS_FUNC('s', (M1 != M2) ? 1 : 0);
     819    case 'L': SS_FUNC('s', (M1 <= M2) ? 1 : 0);
     820    case 'G': SS_FUNC('s', (M1 >= M2) ? 1 : 0);
     821    case 'A': SS_FUNC('s', (M1 && M2) ? 1 : 0);
     822    case 'O': SS_FUNC('s', (M1 || M2) ? 1 : 0);
     823    default:
     824      sprintf (line, "error: op %c not defined!", op[0]);
     825      push_error (line);
     826      return (FALSE);
     827  }
     828# undef SS_FUNC
    1176829
    1177830  clear_stack (V1);
    … …  
    1188841
    1189842  /* only 'N' and 'E' are allowed for WW_binary operations. anything else is either a
    1190    syntax error or is a string which looks like a math expression. */
     843     syntax error or is a string which looks like a math expression. */
    1191844
    1192845  if ((op[0] != 'N') && (op[0] != 'E')) {
    … …  
    1210863
    1211864  switch (op[0]) {
    1212   case 'E':
    1213     value = strcmp (V1[0].name, V2[0].name) ? 0 : 1;
     865    case 'E':
     866      value = strcmp (V1[0].name, V2[0].name) ? 0 : 1;
    1214867    break;
    1215   case 'N':
    1216     value = strcmp (V1[0].name, V2[0].name) ? 1 : 0;
     868    case 'N':
     869      value = strcmp (V1[0].name, V2[0].name) ? 1 : 0;
    1217870    break;
    1218   default:
    1219     sprintf (line, "error: op %c not defined for string operations!", op[0]);
    1220     push_error (line);
    1221     return (FALSE);
     871    default:
     872      sprintf (line, "error: op %c not defined for string operations!", op[0]);
     873      push_error (line);
     874      return (FALSE);
    1222875  }
    1223876
    1224877escape:
    1225   OUT[0].Float = value;
     878  OUT[0].FltValue = value;
    1226879  OUT[0].type = 'S';
    1227   OUT[0].ptr = &OUT[0].Float;
    1228880
    1229881  clear_stack (V1);
    … …  
    1236888int S_unary (StackVar *OUT, StackVar *V1, char *op) {
    1237889
    1238   float *out, *M1;
     890  char line[512]; // this is only used to report an error
    1239891 
    1240   out = OUT[0].ptr = V1[0].ptr;
    1241   M1  = V1[0].ptr;
    1242 
    1243   if (!strcmp (op, "="))     {    }
    1244   if (!strcmp (op, "abs"))   {    *out = fabs(*M1);           }
    1245   if (!strcmp (op, "int"))   {    *out = (float)(int)(*M1);   }
    1246   if (!strcmp (op, "exp"))   {    *out = exp (*M1);           }
    1247   if (!strcmp (op, "ten"))   {    *out = pow (10.0,*M1);      }
    1248   if (!strcmp (op, "log"))   {    *out = log10 (*M1);         }
    1249   if (!strcmp (op, "ln"))    {    *out = log (*M1);           }
    1250   if (!strcmp (op, "sqrt"))  {    *out = sqrt (*M1);          }
    1251   if (!strcmp (op, "erf"))   {    *out = erf (*M1);           }
    1252 
    1253   if (!strcmp (op, "sinh"))  {    *out = sinh (*M1);          }
    1254   if (!strcmp (op, "cosh"))  {    *out = cosh (*M1);          }
    1255   if (!strcmp (op, "asinh")) {    *out = asinh (*M1);         }
    1256   if (!strcmp (op, "acosh")) {    *out = acosh (*M1);         }
    1257   if (!strcmp (op, "lgamma")) {   *out = lgamma (*M1);        }
    1258 
    1259   if (!strcmp (op, "sin"))   {    *out = sin (*M1);           }
    1260   if (!strcmp (op, "cos"))   {    *out = cos (*M1);           }
    1261   if (!strcmp (op, "tan"))   {    *out = tan (*M1);           }
    1262   if (!strcmp (op, "dsin"))  {    *out = sin (*M1*RAD_DEG);   }
    1263   if (!strcmp (op, "dcos"))  {    *out = cos (*M1*RAD_DEG);   }
    1264   if (!strcmp (op, "dtan"))  {    *out = tan (*M1*RAD_DEG);   }
    1265   if (!strcmp (op, "asin"))  {    *out = asin (*M1);          }
    1266   if (!strcmp (op, "acos"))  {    *out = acos (*M1);          }
    1267   if (!strcmp (op, "atan"))  {    *out = atan (*M1);          }
    1268   if (!strcmp (op, "dasin")) {    *out = asin (*M1)*DEG_RAD;  }
    1269   if (!strcmp (op, "dacos")) {    *out = acos (*M1)*DEG_RAD;  }
    1270   if (!strcmp (op, "datan")) {    *out = atan (*M1)*DEG_RAD;  }
    1271   if (!strcmp (op, "rnd"))   {    *out = drand48();           }
    1272   if (!strcmp (op, "not"))   {    *out = !(*M1);              }
    1273   if (!strcmp (op, "--"))    {    *out = - (*M1);             }
    1274   if (!strcmp (op, "isinf")) {    *out = !finite(*M1);        }
    1275   if (!strcmp (op, "isnan")) {    *out = isnan(*M1);          }
    1276 
    1277   OUT[0].Float = *out;
    1278   OUT[0].type = 'S';
    1279 
    1280   clear_stack (V1);
    1281   return (TRUE);
     892# define S_FUNC(OP,FTYPE) {                     \
     893    if (V1->type == 'S') {                      \
     894      opihi_flt M1  = V1[0].FltValue;           \
     895      OUT[0].type = 'S';                        \
     896      OUT[0].FltValue = OP;                     \
     897      clear_stack (V1);                         \
     898      return (TRUE);                            \
     899    }                                           \
     900    if ((FTYPE == 'S') && (V1->type == 's')) {  \
     901      opihi_int M1  = V1[0].IntValue;           \
     902      OUT[0].type = 'S';                        \
     903      OUT[0].FltValue = OP;                     \
     904      clear_stack (V1);                         \
     905      return (TRUE);                            \
     906    }                                           \
     907    if ((FTYPE == 's') && (V1->type == 's')) {  \
     908      opihi_int M1  = V1[0].IntValue;           \
     909      OUT[0].type = 's';                        \
     910      OUT[0].IntValue = OP;                     \
     911      clear_stack (V1);                         \
     912      return (TRUE);                            \
     913    }                                           \
     914  }
     915
     916  if (!strcmp (op, "="))      S_FUNC(M1, 's');
     917  if (!strcmp (op, "abs"))    S_FUNC(fabs(M1), 's');
     918  if (!strcmp (op, "int"))    S_FUNC((int)(M1), 's');
     919  if (!strcmp (op, "exp"))    S_FUNC(exp (M1), 'S');
     920  if (!strcmp (op, "ten"))    S_FUNC(pow (10.0,M1), 'S');
     921  if (!strcmp (op, "log"))    S_FUNC(log10 (M1), 'S');
     922  if (!strcmp (op, "ln"))     S_FUNC(log (M1), 'S');
     923  if (!strcmp (op, "sqrt"))   S_FUNC(sqrt (M1), 'S');
     924  if (!strcmp (op, "erf"))    S_FUNC(erf (M1), 'S');
     925  if (!strcmp (op, "sinh"))   S_FUNC(sinh (M1), 'S');
     926  if (!strcmp (op, "cosh"))   S_FUNC(cosh (M1), 'S');
     927  if (!strcmp (op, "asinh"))  S_FUNC(asinh (M1), 'S');
     928  if (!strcmp (op, "acosh"))  S_FUNC(acosh (M1), 'S');
     929  if (!strcmp (op, "lgamma")) S_FUNC(lgamma (M1), 'S');
     930  if (!strcmp (op, "sin"))    S_FUNC(sin (M1), 'S');
     931  if (!strcmp (op, "cos"))    S_FUNC(cos (M1), 'S');
     932  if (!strcmp (op, "tan"))    S_FUNC(tan (M1), 'S');
     933  if (!strcmp (op, "dsin"))   S_FUNC(sin (M1*RAD_DEG), 'S');
     934  if (!strcmp (op, "dcos"))   S_FUNC(cos (M1*RAD_DEG), 'S');
     935  if (!strcmp (op, "dtan"))   S_FUNC(tan (M1*RAD_DEG), 'S');
     936  if (!strcmp (op, "asin"))   S_FUNC(asin (M1), 'S');
     937  if (!strcmp (op, "acos"))   S_FUNC(acos (M1), 'S');
     938  if (!strcmp (op, "atan"))   S_FUNC(atan (M1), 'S');
     939  if (!strcmp (op, "dasin"))  S_FUNC(asin (M1)*DEG_RAD, 'S');
     940  if (!strcmp (op, "dacos"))  S_FUNC(acos (M1)*DEG_RAD, 'S');
     941  if (!strcmp (op, "datan"))  S_FUNC(atan (M1)*DEG_RAD, 'S');
     942  if (!strcmp (op, "rnd"))    S_FUNC(M1*0.0 + drand48(), 'S');
     943  if (!strcmp (op, "not"))    S_FUNC(!(M1), 's');
     944  if (!strcmp (op, "--"))     S_FUNC(-1*M1, 's'); // NOTE: opihi_int is signed,
     945  if (!strcmp (op, "isinf"))  S_FUNC(!finite(M1), 'S'); // XXX modify in future
     946  if (!strcmp (op, "isnan"))  S_FUNC(isnan(M1), 'S'); // XXX modify in future   
     947
     948# undef S_FUNC
     949
     950  clear_stack (V1);
     951  sprintf (line, "error: op %s not defined!", op);
     952  push_error (line);
     953  return (FALSE);
    1282954
    1283955}
    … …  
    1286958
    1287959  int i, Nx;
    1288   float *out, *M1;
    1289960 
    1290961  Nx = V1[0].vector[0].Nelements;
    1291  
    1292   if (V1[0].type == 'v') {  /** use V1 as temp buffer **/
    1293     OUT[0].vector = V1[0].vector;
    1294     V1[0].type = 'V'; /* prevent it from being freed below */
    1295   } else {  /* no spare temp buffer */
    1296     OUT[0].vector = InitVector ();
    1297     CopyVector (OUT[0].vector, V1[0].vector);
    1298   }
     962
     963  OUT[0].vector = InitVector ();
    1299964  OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/
    1300   M1  = V1[0].ptr;
    1301   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
    1302 
    1303   if (!strcmp (op, "="))     { } /* already set equal */
    1304   if (!strcmp (op, "abs"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = fabs(*M1);         }}
    1305   if (!strcmp (op, "int"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = (float)(int)(*M1); }}
    1306   if (!strcmp (op, "exp"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = exp(*M1);          }}
    1307   if (!strcmp (op, "ten"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = pow(10.0,*M1);     }}
    1308   if (!strcmp (op, "log"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = log10(*M1);        }}
    1309   if (!strcmp (op, "ln"))    { for (i = 0; i < Nx; i++, out++, M1++) { *out = log(*M1);          }}
    1310   if (!strcmp (op, "sqrt"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = sqrt(*M1);         }}
    1311   if (!strcmp (op, "erf"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = erf(*M1);          }}
    1312 
    1313   if (!strcmp (op, "sinh"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = sinh(*M1);        }}
    1314   if (!strcmp (op, "cosh"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = cosh(*M1);        }}
    1315   if (!strcmp (op, "asinh"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = asinh(*M1);       }}
    1316   if (!strcmp (op, "acosh"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = acosh(*M1);       }}
    1317   if (!strcmp (op, "lgamma")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = lgamma(*M1);      }}
    1318 
    1319   if (!strcmp (op, "sin"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = sin(*M1);          }}
    1320   if (!strcmp (op, "cos"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = cos(*M1);          }}
    1321   if (!strcmp (op, "tan"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = tan(*M1);          }}
    1322   if (!strcmp (op, "dsin"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = sin(*M1*RAD_DEG);  }}
    1323   if (!strcmp (op, "dcos"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = cos(*M1*RAD_DEG);  }}
    1324   if (!strcmp (op, "dtan"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = tan(*M1*RAD_DEG);  }}
    1325   if (!strcmp (op, "asin"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = asin(*M1);         }}
    1326   if (!strcmp (op, "acos"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = acos(*M1);         }}
    1327   if (!strcmp (op, "atan"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = atan(*M1);         }}
    1328   if (!strcmp (op, "dasin")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = asin(*M1)*DEG_RAD; }}
    1329   if (!strcmp (op, "dacos")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = acos(*M1)*DEG_RAD; }}
    1330   if (!strcmp (op, "datan")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = atan(*M1)*DEG_RAD; }}
    1331   if (!strcmp (op, "rnd"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = drand48();         }}
    1332   if (!strcmp (op, "ramp"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = i;                 }}
    1333   if (!strcmp (op, "zero"))  { for (i = 0; i < Nx; i++, out++, M1++) { *out = 0;                 }}
    1334   if (!strcmp (op, "not"))   { for (i = 0; i < Nx; i++, out++, M1++) { *out = !(*M1);            }}
    1335   if (!strcmp (op, "--"))    { for (i = 0; i < Nx; i++, out++, M1++) { *out = -(*M1);            }}
    1336   if (!strcmp (op, "isinf")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = !finite(*M1);      }}
    1337   if (!strcmp (op, "isnan")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = isnan(*M1);        }}
    1338 
    1339   /* xramp and yramp only make sense in for matrices. for vectors, xramp = ramp, yramp = zero */
    1340   if (!strcmp (op, "xramp")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = i;                 }}
    1341   if (!strcmp (op, "yramp")) { for (i = 0; i < Nx; i++, out++, M1++) { *out = 0;                 }}
     965
     966# define V_FUNC(OP,FTYPE) {                                     \
     967    if (V1->vector->type == OPIHI_FLT) {                        \
     968      CopyVector (OUT[0].vector, V1[0].vector);                 \
     969      opihi_flt *M1  = V1[0].vector[0].elements.Flt;            \
     970      opihi_flt *out = OUT[0].vector[0].elements.Flt;           \
     971      for (i = 0; i < Nx; i++, out++, M1++) {                   \
     972        *out = OP;                                              \
     973      }                                                         \
     974      clear_stack (V1);                                         \
     975      return (TRUE);                                            \
     976    }                                                           \
     977    if ((V1->vector->type == OPIHI_INT) && (FTYPE == 'S')) {    \
     978      MatchVector (OUT[0].vector, V1[0].vector, OPIHI_FLT);     \
     979      opihi_int *M1  = V1[0].vector[0].elements.Int;            \
     980      opihi_flt *out = OUT[0].vector[0].elements.Flt;           \
     981      for (i = 0; i < Nx; i++, out++, M1++) {                   \
     982        *out = OP;                                              \
     983      }                                                         \
     984      clear_stack (V1);                                         \
     985      return (TRUE);                                            \
     986    }                                                           \
     987    if ((V1->vector->type == OPIHI_INT) && (FTYPE == 's')) {    \
     988      CopyVector (OUT[0].vector, V1[0].vector);                 \
     989      opihi_int *M1  = V1[0].vector[0].elements.Int;            \
     990      opihi_int *out = OUT[0].vector[0].elements.Int;           \
     991      for (i = 0; i < Nx; i++, out++, M1++) {                   \
     992        *out = OP;                                              \
     993      }                                                         \
     994      clear_stack (V1);                                         \
     995      return (TRUE);                                            \
     996    } }                                                 
     997
     998  if (!strcmp (op, "="))      V_FUNC(*M1, 's');
     999  if (!strcmp (op, "abs"))    V_FUNC(fabs(*M1), 's');
     1000  if (!strcmp (op, "int"))    V_FUNC((int)(*M1), 's');
     1001  if (!strcmp (op, "exp"))    V_FUNC(exp(*M1), 'S');
     1002  if (!strcmp (op, "ten"))    V_FUNC(pow(10.0,*M1), 'S');
     1003  if (!strcmp (op, "log"))    V_FUNC(log10(*M1), 'S');
     1004  if (!strcmp (op, "ln"))     V_FUNC(log(*M1), 'S');
     1005  if (!strcmp (op, "sqrt"))   V_FUNC(sqrt(*M1), 'S');
     1006  if (!strcmp (op, "erf"))    V_FUNC(erf(*M1), 'S');
     1007  if (!strcmp (op, "sinh"))   V_FUNC(sinh(*M1), 'S');
     1008  if (!strcmp (op, "cosh"))   V_FUNC(cosh(*M1), 'S');
     1009  if (!strcmp (op, "asinh"))  V_FUNC(asinh(*M1), 'S');
     1010  if (!strcmp (op, "acosh"))  V_FUNC(acosh(*M1), 'S');
     1011  if (!strcmp (op, "lgamma")) V_FUNC(lgamma(*M1), 'S');
     1012  if (!strcmp (op, "sin"))    V_FUNC(sin(*M1), 'S');
     1013  if (!strcmp (op, "cos"))    V_FUNC(cos(*M1), 'S');
     1014  if (!strcmp (op, "tan"))    V_FUNC(tan(*M1), 'S');
     1015  if (!strcmp (op, "dsin"))   V_FUNC(sin(*M1*RAD_DEG), 'S');
     1016  if (!strcmp (op, "dcos"))   V_FUNC(cos(*M1*RAD_DEG), 'S');
     1017  if (!strcmp (op, "dtan"))   V_FUNC(tan(*M1*RAD_DEG), 'S');
     1018  if (!strcmp (op, "asin"))   V_FUNC(asin(*M1), 'S');
     1019  if (!strcmp (op, "acos"))   V_FUNC(acos(*M1), 'S');
     1020  if (!strcmp (op, "atan"))   V_FUNC(atan(*M1), 'S');
     1021  if (!strcmp (op, "dasin"))  V_FUNC(asin(*M1)*DEG_RAD, 'S');
     1022  if (!strcmp (op, "dacos"))  V_FUNC(acos(*M1)*DEG_RAD, 'S');
     1023  if (!strcmp (op, "datan"))  V_FUNC(atan(*M1)*DEG_RAD, 'S');
     1024  if (!strcmp (op, "rnd"))    V_FUNC(drand48(), 'S');
     1025  if (!strcmp (op, "ramp"))   V_FUNC(i, 's');
     1026  if (!strcmp (op, "zero"))   V_FUNC(0, 's');
     1027  if (!strcmp (op, "not"))    V_FUNC(!(*M1), 's');
     1028  if (!strcmp (op, "--"))     V_FUNC(-1*(*M1), 's'); // NOTE: opihi_int is signed
     1029  if (!strcmp (op, "isinf"))  V_FUNC(!finite(*M1), 'S');
     1030  if (!strcmp (op, "isnan"))  V_FUNC(isnan(*M1), 'S');
     1031  if (!strcmp (op, "xramp"))  V_FUNC(i, 's');
     1032  if (!strcmp (op, "yramp"))  V_FUNC(0, 's');
     1033  /* xramp and yramp above only make sense for matrices. for vectors, xramp = ramp, yramp = zero */
     1034
     1035# undef V_FUNC
    13421036
    13431037  if (V1[0].type == 'v') {
    1344     free (V1[0].vector[0].elements);
     1038    free (V1[0].vector[0].elements.Ptr);
    13451039    free (V1[0].vector);
    13461040    V1[0].vector = NULL;
    … …  
    13681062  }
    13691063  OUT[0].type = 'm';      /*** <<--- says this is a temporary matrix ***/
    1370   M1  = V1[0].ptr;
    1371   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     1064  M1  = (float *) V1[0].buffer[0].matrix.buffer;
     1065  out = (float *)OUT[0].buffer[0].matrix.buffer;
    13721066
    13731067  if (!strcmp (op, "="))     { }
    13741068  if (!strcmp (op, "abs"))   { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = fabs(*M1);         }}
    1375   if (!strcmp (op, "int"))   { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = (float)(int)(*M1); }}
     1069  if (!strcmp (op, "int"))   { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = (opihi_flt)(int)(*M1); }}
    13761070  if (!strcmp (op, "exp"))   { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = exp(*M1);          }}
    13771071  if (!strcmp (op, "ten"))   { for (i = 0; i < Nx*Ny; i++, out++, M1++) { *out = pow(10.0,*M1);     }}
    … …  
    14111105    for (j = 0; j < Ny; j++) {
    14121106      for (i = 0; i < Nx; i++, out++, M1++) {
    1413         *out = i;
     1107        *out = i;
    14141108      }
    14151109    }
    … …  
    14181112    for (j = 0; j < Ny; j++) {
    14191113      for (i = 0; i < Nx; i++, out++, M1++) {
    1420         *out = j;
     1114        *out = j;
    14211115      }
    14221116    }

  • trunk/Ohana/src/opihi/mana/findpeaks.c

    r7917 r20936  
    7676  }
    7777
    78   REALLOCATE (vecx[0].elements, float, MAX (Npeak, 1));
    79   REALLOCATE (vecy[0].elements, float, MAX (Npeak, 1));
    80   REALLOCATE (vecz[0].elements, float, MAX (Npeak, 1));
     78  ResetVector (vecx, OPIHI_FLT, MAX (Npeak, 1));
     79  ResetVector (vecy, OPIHI_FLT, MAX (Npeak, 1));
     80  ResetVector (vecz, OPIHI_FLT, MAX (Npeak, 1));
     81
    8182  /* eliminate non-local peaks */
    8283  for (N = n = 0; n < Npeak; n++) {
    8384    if (!keep[n]) continue;
    84     vecx[0].elements[N] = xp[n];
    85     vecy[0].elements[N] = yp[n];
    86     vecz[0].elements[N] = zp[n];
     85    vecx[0].elements.Flt[N] = xp[n];
     86    vecy[0].elements.Flt[N] = yp[n];
     87    vecz[0].elements.Flt[N] = zp[n];
    8788    N ++;
    8889  }
    … …  
    9293  free (keep);
    9394
    94   REALLOCATE (vecx[0].elements, float, MAX (N, 1));
    95   REALLOCATE (vecy[0].elements, float, MAX (N, 1));
    96   REALLOCATE (vecz[0].elements, float, MAX (N, 1));
     95  REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (N, 1));
     96  REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (N, 1));
     97  REALLOCATE (vecz[0].elements.Flt, opihi_flt, MAX (N, 1));
    9798  vecx[0].Nelements = vecy[0].Nelements = vecz[0].Nelements = N;
    9899

  • trunk/Ohana/src/opihi/mana/fitcontour.c

    r16059 r20936  
    1818  yo = atof (argv[4]);
    1919
     20  // require these to be float vectors
     21  REQUIRE_VECTOR_FLT (vecx, FALSE);
     22  REQUIRE_VECTOR_FLT (vecy, FALSE);
     23
    2024  ALLOCATE (B, double *, NTERM);
    2125  ALLOCATE (C, double *, NTERM);
    … …  
    3236  */
    3337  for (i = 0; i < vecx[0].Nelements; i++) {
    34     x = vecx[0].elements[i] - xo;
    35     y = vecy[0].elements[i] - yo;
     38    x = vecx[0].elements.Flt[i] - xo;
     39    y = vecy[0].elements.Flt[i] - yo;
    3640    r = hypot (x, y);
    3741

  • trunk/Ohana/src/opihi/mana/rawstars.c

    r7917 r20936  
    5555  Np = xp[0].Nelements;
    5656
    57   REALLOCATE (xc[0].elements, float, Np);
    58   REALLOCATE (yc[0].elements, float, Np);
    59   REALLOCATE (sx[0].elements, float, Np);
    60   REALLOCATE (sy[0].elements, float, Np);
    61   REALLOCATE (sxy[0].elements, float, Np);
    62   REALLOCATE (zs[0].elements, float, Np);
    63   REALLOCATE (zc[0].elements, float, Np);
    64   REALLOCATE (sk[0].elements, float, Np);
    65   xc[0].Nelements = yc[0].Nelements = sx[0].Nelements = Np;
    66   sy[0].Nelements = zs[0].Nelements = zc[0].Nelements = Np;
    67   sxy[0].Nelements = sk[0].Nelements = Np;
     57  ResetVector (xc, OPIHI_FLT, Np);
     58  ResetVector (yc, OPIHI_FLT, Np);
     59  ResetVector (sx, OPIHI_FLT, Np);
     60  ResetVector (sy, OPIHI_FLT, Np);
     61  ResetVector (sxy, OPIHI_FLT, Np);
     62  ResetVector (zs, OPIHI_FLT, Np);
     63  ResetVector (zc, OPIHI_FLT, Np);
     64  ResetVector (sk, OPIHI_FLT, Np);
    6865
    6966  v = (float *) buff[0].matrix.buffer;
    7067  for (i = 0; i < Np; i++) {
    71     x = xp[0].elements[i];
    72     y = yp[0].elements[i];
     68    x = (xp[0].type == OPIHI_FLT) ? xp[0].elements.Flt[i] : xp[0].elements.Int[i];
     69    y = (yp[0].type == OPIHI_FLT) ? yp[0].elements.Flt[i] : yp[0].elements.Int[i];
    7370    if (x < 0) continue;
    7471    if (x >= Nx) continue;
    … …  
    7774
    7875    get_rough_star (v, Nx, Ny, x, y,
    79                     &xc[0].elements[i],
    80                     &yc[0].elements[i],
    81                     &sx[0].elements[i],
    82                     &sy[0].elements[i],
    83                     &sxy[0].elements[i],
    84                     &zs[0].elements[i],
    85                     &zc[0].elements[i],
    86                     &sk[0].elements[i]);
     76                    &xc[0].elements.Flt[i],
     77                    &yc[0].elements.Flt[i],
     78                    &sx[0].elements.Flt[i],
     79                    &sy[0].elements.Flt[i],
     80                    &sxy[0].elements.Flt[i],
     81                    &zs[0].elements.Flt[i],
     82                    &zc[0].elements.Flt[i],
     83                    &sk[0].elements.Flt[i]);
    8784  }
    8885

  • trunk/Ohana/src/opihi/mana/starcontour.c

    r7917 r20936  
    2222  N = 0;
    2323  Npts = 100;
    24   REALLOCATE (vecx[0].elements, float, MAX (Npts, 1));
    25   REALLOCATE (vecy[0].elements, float, MAX (Npts, 1));
     24  ResetVector (vecx, OPIHI_FLT, MAX (Npts, 1));
     25  ResetVector (vecy, OPIHI_FLT, MAX (Npts, 1));
    2626
    2727  Nx = buf[0].matrix.Naxis[0];
    … …  
    4141        min = TRUE;
    4242        xmin = x + (zo - zt)/(v[x + 1 + y*Nx] - zt);
    43         vecx[0].elements[N] = xmin;
    44         vecy[0].elements[N] = y;
     43        vecx[0].elements.Flt[N] = xmin;
     44        vecy[0].elements.Flt[N] = y;
    4545        N ++;
    4646        if (N >= Npts) {
    4747          Npts += 100;
    48           REALLOCATE (vecx[0].elements, float, MAX (Npts, 1));
    49           REALLOCATE (vecy[0].elements, float, MAX (Npts, 1));
     48          REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (Npts, 1));
     49          REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (Npts, 1));
    5050        }
    5151      }
    … …  
    5959        max = TRUE;
    6060        xmax = x - (zo - zt)/(v[x - 1 + y*Nx] - zt);
    61         vecx[0].elements[N] = xmax;
    62         vecy[0].elements[N] = y;
     61        vecx[0].elements.Flt[N] = xmax;
     62        vecy[0].elements.Flt[N] = y;
    6363        N ++;
    6464        if (N >= Npts) {
    6565          Npts += 100;
    66           REALLOCATE (vecx[0].elements, float, MAX (Npts, 1));
    67           REALLOCATE (vecy[0].elements, float, MAX (Npts, 1));
     66          REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (Npts, 1));
     67          REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (Npts, 1));
    6868        }
    6969      }
    … …  
    8686        min = TRUE;
    8787        xmin = x + (zo - zt)/(v[x + 1 + y*Nx] - zt);
    88         vecx[0].elements[N] = xmin;
    89         vecy[0].elements[N] = y;
     88        vecx[0].elements.Flt[N] = xmin;
     89        vecy[0].elements.Flt[N] = y;
    9090        N ++;
    9191        if (N >= Npts) {
    9292          Npts += 100;
    93           REALLOCATE (vecx[0].elements, float, MAX (Npts, 1));
    94           REALLOCATE (vecy[0].elements, float, MAX (Npts, 1));
     93          REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (Npts, 1));
     94          REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (Npts, 1));
    9595        }
    9696      }
    … …  
    104104        max = TRUE;
    105105        xmax = x - (zo - zt)/(v[x - 1 + y*Nx] - zt);
    106         vecx[0].elements[N] = xmax;
    107         vecy[0].elements[N] = y;
     106        vecx[0].elements.Flt[N] = xmax;
     107        vecy[0].elements.Flt[N] = y;
    108108        N ++;
    109109        if (N >= Npts) {
    110110          Npts += 100;
    111           REALLOCATE (vecx[0].elements, float, MAX (Npts, 1));
    112           REALLOCATE (vecy[0].elements, float, MAX (Npts, 1));
     111          REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (Npts, 1));
     112          REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (Npts, 1));
    113113        }
    114114      }

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

    r20536 r20936  
    261261        fprintf (stderr, "\n");
    262262    }
     263    return (TRUE);
    263264}
    264265
    … …  
    286287
    287288  int **gotstar, **gridmeas;
    288   int i, j, k, N, Nmax, Ngood, Nbad, Nmos, Ncal, Nrel, Nsys, Nfit;
     289  int i, j, k, N, Ngood, Nbad, Nmos, Ncal, Nrel, Nsys;
    289290  double **A, **B, *Mjx, *Wjx;
    290   float Msys, Mrel, Mcal, Mmos, Merr, Wsys;
     291  float Msys, Mcal, Mmos, Merr, Wsys;
    291292  double Mj, Wj;
    292293 
    … …  
    449450
    450451    FILE *f;
    451     Header header, theader;
     452    Header theader;
    452453    Matrix matrix;
    453454

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

    r20323 r20936  
    166166void matchImage (Catalog *catalog, int meas, int cat) {
    167167
    168   int i, ave, ccdnum;
    169   double ra, dec, X, Y;
     168  int i, ccdnum;
     169  double X, Y;
    170170  char *pname, *filter, *p, base[256];
    171171  Measure *measure;
    … …  
    191191         and nn is an integer -> ccdnum */
    192192     
     193      /// XXX we have an inconsistency here wrt dvo.layout and dvo.photcode
     194
    193195      while (!isdigit(*p) && *p) p++;
    194196      if (*p == 0) continue;

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

    r20323 r20936  
    547547  double *xlist, *Mlist;
    548548  Graphdata graphdata;
    549   char *filename, tmp;
    550549
    551550# define NBIN 200

  • trunk/Ohana/src/skycalc/src/astro.c

    r19681 r20936  
    106106
    107107  double incl;
    108   double xpr,ypr,zpr;
     108  double ypr,zpr;
    109109  double T;
    110110
    … …  
    141141double SC_etcorr (double jd) {
    142142
    143   double jd1900 = 2415019.5;
    144143  double dates[20] = {1900,1905,1910,1915,1920,1925,1930,1935,1940,1945,
    145144                      1950,1955,1960,1965,1970,1975,1980,1985,1990,1993};

  • trunk/Ohana/src/skycalc/src/dusktime.c

    r19681 r20936  
    1313}
    1414
    15 main (int argc, char **argv) {
     15int main (int argc, char **argv) {
    1616
    1717  struct SC_date_time date, tmpdate;
    … …  
    5959
    6060  if (VERBOSE) {
    61     jd_to_date (jdnow, &tmpdate);
     61    SC_jd_to_date (jdnow, &tmpdate);
    6262    fprintf (stderr, "%4d/%02d/%02d %02d:%02d:%02f\n", tmpdate.y, tmpdate.mo, tmpdate.d, tmpdate.h, tmpdate.mn, tmpdate.s);
    6363  }

  • trunk/Ohana/src/skycalc/src/geometry.c

    r19681 r20936  
    88   double mod;    /* modulus */
    99   double xy;     /* component in xy plane */
    10    short sign;    /* for determining quadrant */
    1110   double radian_ra, radian_dec;
    1211

  • trunk/Ohana/src/skycalc/src/moon.c

    r19681 r20936  
    368368  double geora, geodec, geodist;  /* geocent for moon, not used here.*/
    369369  double ramoon, decmoon, distmoon;
    370   double hamoonrise, hamoonset, tmoonrise, tmoonset, jdmoonrise, jdmoonset;
    371   short dow; /* day of week */
    372   struct SC_date_time date_midnight, tmpdate;
     370  double hamoonset, tmoonset, jdmoonset;
     371  struct SC_date_time date_midnight;
    373372  double dt, lst0, lst1, djd, horiz;
    374373
    … …  
    420419  double geora, geodec, geodist;  /* geocent for moon, not used here.*/
    421420  double ramoon, decmoon, distmoon;
    422   double hamoonrise, hamoonset, tmoonrise, tmoonset, jdmoonrise, jdmoonset;
    423   short dow; /* day of week */
    424   struct SC_date_time date_midnight, tmpdate;
     421  double hamoonset, tmoonrise, jdmoonrise;
     422  struct SC_date_time date_midnight;
    425423  double dt, lst0, lst1, djd, horiz;
    426424

  • trunk/Ohana/src/skycalc/src/moondata.c

    r19681 r20936  
    1212}
    1313
    14 main (int argc, char **argv) {
     14int main (int argc, char **argv) {
    1515
    16   struct SC_date_time date, tmpdate;
     16  struct SC_date_time date;
    1717  double longit, lat, elevsea, elev;
    1818  double jdnow, ra, dec, sid;

  • trunk/Ohana/src/skycalc/src/sun.c

    r19681 r20936  
    55void SC_lpsun (double jd, double *ra, double *dec) {
    66
    7   double n, L, g, lambda,epsilon,alpha,delta,x,y,z;
     7  double n, L, g, lambda,epsilon,x,y,z;
    88
    99  n = jd - J2000;
    … …  
    5454}
    5555
    56 /* Given site position, prints Sun info for the given night.
     56/* Given site position, prints Sun info for the given night. */
    5757/* dates are all in UT now */
    5858double SC_sunset_tonight (struct SC_date_time date, double lat, double longit, double elev) {
    5959
    6060  double jd, jdmid0, jdmid, stmid;
    61   double rasun, decsun, min_alt, max_alt, horiz;
    62   double hasunset, jdsunset, jdsunrise, sid;
     61  double rasun, decsun, horiz;
     62  double hasunset, jdsunset;
    6363  double dt, lst0, lst1, djd;
    64   struct SC_date_time date_midnight, tmpdate;
    65   short dow;
     64  struct SC_date_time date_midnight;
    6665
    6766  horiz = sqrt (2. * elev / 6378140.) * DEG_IN_RADIAN;
    … …  
    106105}
    107106
    108 /* Given site position, prints Sun info for the given night.
     107/* Given site position, prints Sun info for the given night. */
    109108/* dates are all in UT now */
    110109double SC_sunrise_tonight (struct SC_date_time date, double lat, double longit, double elev) {
    111110
    112111  double jd, jdmid, stmid;
    113   double rasun, decsun, min_alt, max_alt, horiz;
    114   double hasunset, jdsunset, jdsunrise, sid;
     112  double rasun, decsun, horiz;
     113  double hasunset, jdsunrise;
    115114  double dt, lst0, lst1, djd;
    116   struct SC_date_time date_midnight, tmpdate;
    117   short dow;
     115  struct SC_date_time date_midnight;
    118116
    119117  horiz = sqrt (2. * elev / 6378140.) * DEG_IN_RADIAN;

  • trunk/Ohana/src/skycalc/src/sundata.c

    r19731 r20936  
    1212}
    1313
    14 main (int argc, char **argv) {
     14int main (int argc, char **argv) {
    1515
    16   struct SC_date_time date, tmpdate;
     16  struct SC_date_time date;
    1717  double longit, lat, elevsea, elev;
    18   double jdnow, ra, dec, sid, alt, az, sind, sinh, cosh;
    19   double geora, geodec, geodist, dist;
     18  double jdnow, sid, alt, az, sind, sinh, cosh;
    2019  double RAo, DECo, abx, aby, abz, cs, theta;
    21   double Rsun, Dsun, days, Hsun;
     20  double Rsun, Dsun, Hsun;
    2221  time_t tzero;
    2322  struct tm *stm;

  • trunk/Ohana/src/skycalc/src/sunmoon.c

    r19730 r20936  
    99double angular_separation (double ra, double dec, double RA, double DEC);
    1010
    11 main (int argc, char **argv) {
     11int main (int argc, char **argv) {
    1212
    1313  int N;
    14   struct SC_date_time date, tmpdate;
     14  struct SC_date_time date;
    1515  double longitude, latitude, elevation;
    1616  double jdnow, sid;

  • trunk/Ohana/src/skycalc/src/time.c

    r19681 r20936  
    66  time_t t;
    77  struct tm *stm;
    8   double jd, jdb, jde;
    9   short dow;
    108 
    119  t = time (0);
    … …  
    109107double SC_lst (double jd, double longit) {
    110108 
    111   double t, ut, jdmid, jdint, jdfrac, sid_g, sid;
     109  double t, ut, jdmid, jdint, jdfrac, sid_g;
    112110  long sid_int;
    113111 
Note: See TracChangeset for help on using the changeset viewer.