IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 20859


Ignore:
Timestamp:
Nov 30, 2008, 11:13:15 AM (17 years ago)
Author:
eugene
Message:

allow functions to use FLT or INT vectors as appropriate; document valid types

Location:
branches/eam_branch_20081124/Ohana/src/opihi
Files:
1 added
55 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/biassub.c

    r20839 r20859  
    9191
    9292  if (!NoVector) {
    93     xvec[0].Nelements = yvec[0].Nelements = nlong;
    94     REALLOCATE (xvec[0].elements.Flt, opihi_flt, nlong);
    95     REALLOCATE (yvec[0].elements.Flt, opihi_flt, nlong);
     93    ResetVector (xvec, OPIHI_FLT, nlong);
     94    ResetVector (yvec, OPIHI_FLT, nlong);
    9695    for (i = 0; i < nlong; i++) {
    9796      xvec[0].elements.Flt[i] = i + start;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/coords.c

    r20839 r20859  
    5656      return (FALSE);
    5757    }
     58    REQUIRE_VECTOR_FLT (xvec, FALSE);
     59    REQUIRE_VECTOR_FLT (yvec, FALSE);
    5860    form = VECTOR;
    5961  }     

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/cplot.c

    r20857 r20859  
    3131  }
    3232
    33   ALLOCATE (Xvec.elements.Flt, opihi_flt, xvec[0].Nelements);
    34   ALLOCATE (Yvec.elements.Flt, opihi_flt, xvec[0].Nelements);
    35    
    36   Xvec.Nelements = xvec[0].Nelements;
    37   Yvec.Nelements = xvec[0].Nelements;
     33  ResetVector (Xvec, OPIHI_FLT, xvec[0].Nelements);
     34  ResetVector (Yvec, OPIHI_FLT, xvec[0].Nelements);
    3835 
    3936  r = xvec[0].elements.Flt;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/csystem.c

    r20839 r20859  
    5454  }
    5555 
     56  CastVector (xvec, OPIHI_FLT);
     57  CastVector (yvec, OPIHI_FLT);
     58
    5659  xptr = xvec[0].elements.Flt;
    5760  yptr = yvec[0].elements.Flt;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/czplot.c

    r20857 r20859  
    2828  REQUIRE_VECTOR_FLT (xvec, FALSE);
    2929  REQUIRE_VECTOR_FLT (yvec, FALSE);
     30  REQUIRE_VECTOR_FLT (zvec, FALSE);
    3031
    3132  if (xvec[0].Nelements != yvec[0].Nelements) {
    … …  
    3738    return (FALSE);
    3839  }
    39   Xvec.Nelements = xvec[0].Nelements;
    40   Yvec.Nelements = xvec[0].Nelements;
    41   Zvec.Nelements = zvec[0].Nelements;
    42   ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
    43   ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    44   ALLOCATE (Zvec.elements.Flt, opihi_flt, Zvec.Nelements);
     40  ResetVector (Xvec, OPIHI_FLT, xvec[0].Nelements);
     41  ResetVector (Yvec, OPIHI_FLT, xvec[0].Nelements);
     42  ResetVector (Zvec, OPIHI_FLT, xvec[0].Nelements);
    4543 
    4644  r   = xvec[0].elements.Flt;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/multifit.c

    r20839 r20859  
    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

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/precess.c

    r20839 r20859  
    9090  }
    9191 
    92   for (i = 0; i < xvec[0].Nelements; i++) {
    93     A = xvec[0].elements.Flt[i];
    94     D = yvec[0].elements.Flt[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.Flt[i] = RA;
    107     yvec[0].elements.Flt[i] = DEC;
     112    *Av = RA;
     113    *Dv = DEC;
    108114  }
    109115

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/profile.c

    r20839 r20859  
    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.Flt, opihi_flt, 5*(int)SQ(2*N+1));
    32   REALLOCATE (yvec[0].elements.Flt, opihi_flt, 5*(int)SQ(2*N+1));
     30  ResetVector (xvec, OPIHI_FLT, (int)SQ(2*N+1);
     31  ResetVector (yvec, OPIHI_FLT, (int)SQ(2*N+1);
     32
    3333  bzero (yvec[0].elements.Flt, (int)SQ(2*N+1)*sizeof(opihi_flt)+1);
    3434  V = (float *)(buf[0].matrix.buffer);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.astro/spec.c

    r20839 r20859  
    5555
    5656  N = y2 - y1;
    57   REALLOCATE (xvec[0].elements.Flt, opihi_flt, N);
    58   REALLOCATE (yvec[0].elements.Flt, opihi_flt, 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);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/accum.c

    r20839 r20859  
    3030  if ((out = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    3131
     32  REQUIRE_VECTOR_FLT (val, FALSE);
     33  REQUIRE_VECTOR_FLT (key, FALSE);
     34
    3235  start = atof (argv[4]);
    3336  end   = atof (argv[5]);
    … …  
    4649  Nbins = (end - start) / delta;
    4750
    48   out[0].Nelements = Nbins;
    49   REALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
     51  ResetVector (out, OPIHI_FLT, Nbins);
    5052  bzero (out[0].elements.Flt, sizeof(opihi_flt)*out[0].Nelements);
    5153  if (Normalize) {

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/applyfit.c

    r20839 r20859  
    3636    free (c);
    3737  }
    38   yvec[0].Nelements = xvec[0].Nelements;
    39   REALLOCATE (yvec[0].elements.Flt, opihi_flt, yvec[0].Nelements);
     38
     39  ResetVector (yvec, OPIHI_FLT, xvec[0].Nelements);
    4040  bzero (yvec[0].elements.Flt, sizeof(opihi_flt)*yvec[0].Nelements);
    41   x = xvec[0].elements.Flt;
    4241  y = yvec[0].elements.Flt;
    4342
    44   for (j = 0; j < xvec[0].Nelements; j++, x++, y++) {
    45     X = 1;
    46     for (i = 0; i < order + 1; i++) {
    47       *y += C[i]*X;
    48       X = X * (*x);
     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      }
    4960    }
    5061  }

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/applyfit2d.c

    r20839 r20859  
    4343  }
    4444
    45   zvec[0].Nelements = xvec[0].Nelements;
    46   REALLOCATE (zvec[0].elements.Flt, opihi_flt, zvec[0].Nelements);
     45  ResetVector (zvec, OPIHI_FLT, xvec[0].Nelements);
    4746  bzero (zvec[0].elements.Flt, sizeof(opihi_flt)*zvec[0].Nelements);
    48   x = xvec[0].elements.Flt;
    49   y = yvec[0].elements.Flt;
    5047  z = zvec[0].elements.Flt;
    5148
    52   for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {
    53     Y = X = 1;
    54     for (j = 0; j < order + 1; j++) {
    55       X = Y;
    56       for (i = 0; i < order + 1 - j; i++) {
    57         *z += C[i][j]*X;
    58         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);
    5962      }
    60       Y = Y * (*y);
    6163    }
    6264  }
     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
    63111  for (i = 0; i < order + 1; i++) free (C[i]);
    64112  free (C);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/concat.c

    r20839 r20859  
    1919    Nin = ovec[0].Nelements;
    2020    ovec[0].Nelements++;
    21     REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements);
    22     ovec[0].elements.Flt[Nin] = value;
     21    if (ovec[0].type == OPIHI_FLT) {
     22      REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements);
     23      ovec[0].elements.Flt[Nin] = value;
     24    } else {
     25      REALLOCATE (ovec[0].elements.Int, opihi_int, ovec[0].Nelements);
     26      ovec[0].elements.Int[Nin] = value;
     27    }
    2328    return (TRUE);
    2429  }
    … …  
    2631  if ((ivec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2732 
    28   REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
    29   for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
    30     ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
     33  // we have 4 cases: (ivec == flt or int) and (ovec == flt or int)
     34  if ((ovec[0].type == OPIHI_FLT) && (ivec[0].type == OPIHI_FLT)) {
     35    REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
     36    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     37      ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
     38    }
    3139  }
     40  if ((ovec[0].type == OPIHI_FLT) && (ivec[0].type == OPIHI_INT)) {
     41    REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
     42    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     43      ovec[0].elements.Flt[j] = ivec[0].elements.Int[i];
     44    }
     45  }
     46  if ((ovec[0].type == OPIHI_INT) && (ivec[0].type == OPIHI_INT)) {
     47    REALLOCATE (ovec[0].elements.Int, opihi_int, ovec[0].Nelements + ivec[0].Nelements);
     48    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     49      ovec[0].elements.Int[j] = ivec[0].elements.Int[i];
     50    }
     51  }
     52
     53  // this case forces ovec to be raised to FLT
     54  if ((ovec[0].type == OPIHI_INT) && (ivec[0].type == OPIHI_FLT)) {
     55    ALLOCATE (temp, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
     56    for (i = 0; i < ovec[0].Nelements; i++) {
     57      temp[i] = ovec[0].elements.Int[i];
     58    }
     59    ovec[0].type = OPIHI_FLT;
     60    free (ovec[0].elements.Int);
     61    ovec[0].elements.Flt = temp;
     62    for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
     63      ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
     64    }
     65  }
     66
    3267  ovec[0].Nelements += ivec[0].Nelements;
    33  
    3468  return (TRUE);
    35    
    3669}

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/contour.c

    r20839 r20859  
    9292  N = 0;
    9393  NVEC = 100;
    94   REALLOCATE (xv[0].elements.Flt, opihi_flt, NVEC);
    95   REALLOCATE (yv[0].elements.Flt, opihi_flt, NVEC);
     94  ResetVector (xv, OPIHI_FLT, NVEC);
     95  ResetVector (yv, OPIHI_FLT, NVEC);
    9696
    9797  for (j = 1; j < Ny; j++) {

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/cumulative.c

    r20839 r20859  
    44 
    55  int i;
    6   opihi_flt *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.Flt, opihi_flt, ovec[0].Nelements);
     16
     17  ResetVector (ovec, OPIHI_FLT, ivec[0].Nelements);
    1918  bzero (ovec[0].elements.Flt, sizeof(opihi_flt)*ovec[0].Nelements);
    2019
    21   Vi = ivec[0].elements.Flt;
    2220  Vo = ovec[0].elements.Flt;
    23   *Vo = *Vi;
    24   for (i = 1; i < ivec[0].Nelements; i++, Vi++, Vo++) {
    25     *Vo = Vo[-1] + *Vi;
    26   }     
     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}

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/cut.c

    r20839 r20859  
    4848  case 'X':
    4949    /* create output vectors */
    50     xvec[0].Nelements = yvec[0].Nelements = nx;
    51     REALLOCATE (xvec[0].elements.Flt, opihi_flt, MAX (nx, 1));
    52     REALLOCATE (yvec[0].elements.Flt, opihi_flt, MAX (nx, 1));
     50    ResetVector (xvec, OPIHI_FLT, MAX (nx, 1));
     51    ResetVector (yvec, OPIHI_FLT, MAX (nx, 1));
    5352    bzero (yvec[0].elements.Flt, nx*sizeof(opihi_flt));
    5453    for (i = 0; i < nx; i++) {
    … …  
    8180  case 'y':
    8281  case 'Y':
    83     xvec[0].Nelements = yvec[0].Nelements = ny;
    84     REALLOCATE (xvec[0].elements.Flt, opihi_flt, ny);
    85     REALLOCATE (yvec[0].elements.Flt, opihi_flt, ny);
     82    ResetVector (xvec, OPIHI_FLT, MAX (ny, 1));
     83    ResetVector (yvec, OPIHI_FLT, MAX (ny, 1));
    8684    bzero (yvec[0].elements.Flt, ny*sizeof(opihi_flt));
    8785    for (i = 0; i < ny; i++) {

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/dbselect.c

    r20839 r20859  
    6767      return (FALSE);
    6868    }
    69     REALLOCATE (vec[i][0].elements.Flt, opihi_flt, 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;
    7188  }
    7289
    … …  
    88105          case FIELD_TYPE_INT24:
    89106          case FIELD_TYPE_LONGLONG:
     107            vec[i][0].elements.Int[j] = atol (row[i]);
     108            break;
    90109          case FIELD_TYPE_DECIMAL:
    91110          case FIELD_TYPE_FLOAT:

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/dimendown.c

    r20839 r20859  
    3030  Npix = Nx * Ny;
    3131
    32   vec[0].Nelements = Npix;
    33   REALLOCATE (vec[0].elements.Flt, opihi_flt, Npix);
     32  ResetVector (vec, OPIHI_FLT, Npix);
    3433
    3534  in = (float *) buf[0].matrix.buffer;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/dimenup.c

    r20839 r20859  
    44 
    55  int i, Nx, Ny, Npix;
    6   opihi_flt *in;
    76  float *out;
    87  Vector *vec;
    … …  
    3029
    3130  out = (float *) buf[0].matrix.buffer;
    32   in = vec[0].elements.Flt;
    3331
    34   for (i = 0; i < Npix; i++, in++, out++) {
    35     *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    }
    3642  }
    3743

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/fft1d.c

    r20839 r20859  
    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.Flt, opihi_flt, Npix);
    46   REALLOCATE (Oim[0].elements.Flt, opihi_flt, 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)

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/fit.c

    r20839 r20859  
    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]);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/fit2d.c

    r20839 r20859  
    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 

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/gaussdeviate.c

    r20839 r20859  
    1515  sigma = atof (argv[4]);
    1616
    17   vec[0].Nelements = Npts;
    18   REALLOCATE (vec[0].elements.Flt, opihi_flt, Npts);
     17  ResetVector (vec, OPIHI_FLT, Npts);
    1918
    2019  gauss_init (2048);
    … …  
    4645  sigma = atof (argv[4]);
    4746
    48   vec[0].Nelements = Npts;
    49   REALLOCATE (vec[0].elements.Flt, opihi_flt, Npts);
     47  ResetVector (vec, OPIHI_FLT, Npts);
    5048
    5149  gauss_init (Npts);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/gaussj.c

    r20839 r20859  
    44
    55  float *m;
    6   opihi_flt *v;
     6  opihi_flt *vf;
     7  opihi_int *vi;
    78  double **a, **b;
    89  int i, j, N, status, QUIET;
    … …  
    3233  }
    3334
     35  isFloat = (B[0].type == OPIHI_FLT);
     36  vf = B[0].elements.Flt;
     37  vi = B[0].elements.Int;
     38
    3439  m = (float *) A[0].matrix.buffer;
    35   v = B[0].elements.Flt;
    3640  for (i = 0; i < N; i++) {
    3741    for (j = 0; j < N; j++) {
    3842      a[i][j] = m[i+j*N];
    3943    }
    40     b[i][0] = v[i];
     44    b[i][0] = isFloat ? vf[i] : vi[i];
    4145  }
    4246
    4347  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;
    4452
    4553  for (i = 0; i < N; i++) {
    … …  
    4755       m[i+j*N] = a[i][j];
    4856    }
    49     v[i] = b[i][0];
     57    vf[i] = b[i][0];
    5058  }
    5159

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/grid.c

    r20857 r20859  
    2323
    2424  N = 0;
    25   Xvec.Nelements = 200;
    26   Yvec.Nelements = 200;
    27   ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
    28   ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     25  ResetVector (Xvec, OPIHI_FLT, 200);
     26  ResetVector (Yvec, OPIHI_FLT, 200);
    2927
    3028  major = minor = 1;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/gridify.c

    r20839 r20859  
    2929  if (vx[0].Nelements != vy[0].Nelements) return (FALSE);
    3030  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);
    3135
    3236  Xmin = atof (argv[5]);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/histogram.c

    r20839 r20859  
    44 
    55  int i, bin, Nbins;
     6  opihi_int *OUT;
    67  opihi_flt start, end, delta;
    7   opihi_flt *V;
    88  Vector *xvec, *yvec;
    99
    … …  
    3131  if ((xvec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    3232  if ((yvec = SelectVector (argv[2], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    33   yvec[0].Nelements = Nbins;
    34    
    35   REALLOCATE (yvec[0].elements.Flt, opihi_flt, yvec[0].Nelements);
    36   bzero (yvec[0].elements.Flt, sizeof(opihi_flt)*yvec[0].Nelements);
    37   if (Nbins < 1) {
    38       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    }     
    3953  }
    40 
    41   V = xvec[0].elements.Flt;
    42   for (i = 0; i < xvec[0].Nelements; i++, V++) {
    43     if (isnan(*V)) continue;
    44     bin = MIN (MAX (0, (*V - start) / delta), Nbins - 1);
    45     yvec[0].elements.Flt[bin] += 1.0;
    46   }     
    4754
    4855  return (TRUE);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/imcut.c

    r20839 r20859  
    3737  dY = dY / L;
    3838
    39   REALLOCATE (xvec[0].elements.Flt, opihi_flt, MAX (L, 1));
    40   REALLOCATE (yvec[0].elements.Flt, opihi_flt, 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;

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/imhist.c

    r20839 r20859  
    105105  } 
    106106
    107   vec1[0].Nelements = Nbins + 1;
    108   vec2[0].Nelements = Nbins + 1;
    109   REALLOCATE (vec1[0].elements.Flt, opihi_flt, vec1[0].Nelements);
     107  ResetVector (vec1, OPIHI_FLT, Nbins + 1);
     108  ResetVector (vec2, OPIHI_FLT, Nbins + 1);
    110109  bzero (vec1[0].elements.Flt, vec1[0].Nelements*sizeof(opihi_flt));
    111   REALLOCATE (vec2[0].elements.Flt, opihi_flt, vec2[0].Nelements);
    112110  bzero (vec2[0].elements.Flt, vec2[0].Nelements*sizeof(opihi_flt));
    113111 

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/integrate.c

    r20839 r20859  
    33int integrate (int argc, char **argv) {
    44 
    5   int i, N, VERBOSE;
     5  int i, N, VERBOSE, isFloat;
    66  opihi_flt *X, *Y;
    7   double start, end, value, range;
     7  double start, end, value, range, dvalue;
    88  Vector *vecx, *vecy;
    99
    … …  
    2525  end   = atof (argv[4]);
    2626
    27   X = vecx[0].elements.Flt;
    28   Y = vecy[0].elements.Flt;
     27  isFloat = vecy[0].type == OPIHI_FLT;
     28  Yf = vecy[0].elements.Flt;
     29  Yi = vecy[0].elements.Int;
    2930
    3031  value = 0;
    3132  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   }     
     33
     34  if (vecx[0].type == OPIHI_FLT) {
     35    opihi_flt *X = vecx[0].elements.Flt;
     36    for (i = 0; i < vecx[0].Nelements-1; i++, X++, Yi++, Yf++) {
     37      if ((*X >= start) && (*X <= end)) {
     38        dvalue = (isFloat) ? *Yf : *Yi;
     39        value += *Y * (X[1] - X[0]);
     40        range += (X[1] - X[0]);
     41      }
     42    }     
     43  } else {
     44    opihi_int *X = vecx[0].elements.Int;
     45    for (i = 0; i < vecx[0].Nelements-1; i++, X++, Yi++, Yf++) {
     46      if ((*X >= start) && (*X <= end)) {
     47        dvalue = (isFloat) ? *Yf : *Yi;
     48        value += *Y * (X[1] - X[0]);
     49        range += (X[1] - X[0]);
     50      }
     51    }     
     52  }
    3853
    3954  set_variable ("sum", value);

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/sort.c

    r20857 r20859  
    3131}
    3232
     33// XXX add an option to NOT sort, but return an index instead?
    3334int sort_vectors (int argc, char **argv) {
    3435 

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/calmextract.c

    r20839 r20859  
    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.Flt, opihi_flt, NSTAR);
    64     vec[k][0].Nelements = 0;
     66    ResetVector (vec[k], OPIHI_FLT, NSTAR);
    6567  }
    6668

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/ccd.c

    r20839 r20859  
    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

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/cmd.c

    r20839 r20859  
    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

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/cmpread.c

    r20839 r20859  
    8989  fclose (f);
    9090
    91   REALLOCATE (vec[0].elements.Flt, opihi_flt, Nstars);
    92   vec[0].Nelements = Nstars;
     91  ResetVector (vec, OPIHI_FLT, Nstars);
    9392  bzero (vec[0].elements.Flt, Nstars*sizeof(opihi_flt));
    9493

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/compare.c

    r20839 r20859  
    1010  Nmatch = 0;
    1111  NMATCH = D_NMATCH;
    12   REALLOCATE (rvec[0].elements.Flt, opihi_flt, NMATCH);
    13   REALLOCATE (dvec[0].elements.Flt, opihi_flt, NMATCH);
    14   REALLOCATE (mvec[0].elements.Flt, opihi_flt, NMATCH);
    15   REALLOCATE (drvec[0].elements.Flt, opihi_flt, NMATCH);
    16   REALLOCATE (ddvec[0].elements.Flt, opihi_flt, NMATCH);
    17   REALLOCATE (dmvec[0].elements.Flt, opihi_flt, 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);) {
    … …  
    5959  }
    6060
    61   REALLOCATE ( rvec[0].elements.Flt, opihi_flt, Nmatch);
    62   REALLOCATE ( dvec[0].elements.Flt, opihi_flt, Nmatch);
    63   REALLOCATE ( mvec[0].elements.Flt, opihi_flt, Nmatch);
    64   REALLOCATE (drvec[0].elements.Flt, opihi_flt, Nmatch);
    65   REALLOCATE (ddvec[0].elements.Flt, opihi_flt, Nmatch);
    66   REALLOCATE (dmvec[0].elements.Flt, opihi_flt, 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

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/detrend.c

    r20839 r20859  
    151151  N = 0;
    152152  NVALUE = 1000;
    153   REALLOCATE (vec[0].elements.Flt, opihi_flt, NVALUE);
     153  ResetVector (vec, OPIHI_FLT, NVALUE);
    154154  value = vec[0].elements.Flt;
    155155

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/gstar.c

    r20839 r20859  
    136136    N = 0;
    137137    NPTS = 1000;
    138     ALLOCATE (vec1[0].elements.Flt, opihi_flt, NPTS);
    139     ALLOCATE (vec2[0].elements.Flt, opihi_flt, NPTS);
    140     ALLOCATE (vec3[0].elements.Flt, opihi_flt, NPTS);
    141     ALLOCATE (vec4[0].elements.Flt, opihi_flt, 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

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/images.c

    r20857 r20859  
    113113
    114114  npts = NPTS = 200;
    115   ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
    116   ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
     115  ResetVector (Xvec, OPIHI_FLT, NPTS);
     116  ResetVector (Yvec, OPIHI_FLT, NPTS);
     117
    117118  ALLOCATE (plist, int, NPTS);
    118119  n = N = 0;

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/imbox.c

    r20857 r20859  
    3636 
    3737  /* project this image to screen display coords */
    38   ALLOCATE (Xvec.elements.Flt, opihi_flt, 8);
    39   ALLOCATE (Yvec.elements.Flt, opihi_flt, 8);
     38  ResetVector (Xvec, OPIHI_FLT, 8);
     39  ResetVector (Yvec, OPIHI_FLT, 8);
    4040
    4141  while (gfits_fread_header (f, &header)) {

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/imdata.c

    r20839 r20859  
    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.Flt, opihi_flt, NPTS);
    128   vec[0].Nelements = N = 0;
     129  ResetVector (vec, OPIHI_FLT, NPTS);
    129130
    130131  // prepare to handle interrupt signals

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/imdense.c

    r20857 r20859  
    3030  srand48(B);
    3131
     32  N = 0;
    3233  NPTS = 200;
    33   ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
    34   ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    35   N = 0;
     34  ResetVector (Xvec, OPIHI_FLT, Npts);
     35  ResetVector (Yvec, OPIHI_FLT, Npts);
     36
    3637  for (i = 0; i < Nimage; i++) {
    3738    /* choose a position for point within image box */

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/imextract.c

    r20839 r20859  
    165165
    166166  /* create storage vector */
    167   REALLOCATE (vec[0].elements.Flt, opihi_flt, Nimage);
    168   vec[0].Nelements = Nimage;
     167  ResetVector (vec, OPIHI_FLT, Nimage);
    169168 
    170169  N = 0;

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/imrough.c

    r20839 r20859  
    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.Flt, opihi_flt, NVEC);
     136  ResetVector (vec, OPIHI_FLT, NVEC);
    135137  Vec = vec[0].elements.Flt;
    136138

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/imstats.c

    r20857 r20859  
    3333
    3434  /* assign vector values */
    35   Xvec.Nelements = Nimage;
    36   Yvec.Nelements = Nimage;
    37   ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
    38   ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     35  ResetVector (Xvec, OPIHI_FLT, Nimage);
     36  ResetVector (Yvec, OPIHI_FLT, Nimage);
     37
    3938  gprint (GP_LOG, "seq  ra (J2000) dec    time (s)   Nstars\n");
    4039  for (i = 0; i < Nimage; i++) {

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/lcurve.c

    r20857 r20859  
    102102     catalog.average[N1[i]].R = RA[i] */
    103103
     104  N = 0;
    104105  NPTS = 100;
    105   ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
    106   ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
     106  ResetVector (Xvec, OPIHI_FLT, NPTS);
     107  ResetVector (Yvec, OPIHI_FLT, NPTS);
    107108  dYvec.elements.Flt = NULL;
    108   if (ErrorBars) { ALLOCATE (dYvec.elements.Flt, opihi_flt, NPTS); }
    109   N = 0;
     109  if (ErrorBars) {   
     110    ResetVector (Yvec, OPIHI_FLT, NPTS);
     111  }
    110112
    111113  GetTimeFormat (&TimeReference, &TimeFormat);

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/lightcurve.c

    r20839 r20859  
    8787  N = 0;
    8888  NPTS = 100;
    89   REALLOCATE (tvec[0].elements.Flt, opihi_flt, NPTS);
    90   REALLOCATE (mvec[0].elements.Flt, opihi_flt, NPTS);
    91   REALLOCATE (dmvec[0].elements.Flt, opihi_flt, NPTS);
     89  ResetVector (tvec, OPIHI_FLT, Npts);
     90  ResetVector (mvec, OPIHI_FLT, Npts);
     91  ResetVector (dmvec, OPIHI_FLT, Npts);
    9292 
    9393  GetTimeFormat (&TimeReference, &TimeFormat);

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/procks.c

    r20857 r20859  
    9595
    9696  /* data has been loaded, get ready to plot it */
    97   Yvec.Nelements = Xvec.Nelements = 3*Nrocks;
    98   ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
    99   ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     97  ResetVector (Xvec, OPIHI_FLT, 3*Nrocks);
     98  ResetVector (Yvec, OPIHI_FLT, 3*Nrocks);
    10099 
    101100  /* project stars to screen display coords */

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/showtile.c

    r20857 r20859  
    2222  N = 0;
    2323  NPTS = 200;
    24   ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
    25   ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
     24  ResetVector (Xvec, OPIHI_FLT, NPTS);
     25  ResetVector (Yvec, OPIHI_FLT, NPTS);
    2626
    2727  /* starting position */

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/simage.c

    r20857 r20859  
    9292
    9393  /* set up storage buffers */
    94   Xvec.Nelements = Nstars;
    95   Yvec.Nelements = Nstars;
    96   Zvec.Nelements = Nstars;
    97   ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
    98   ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    99   ALLOCATE (Zvec.elements.Flt, opihi_flt, Zvec.Nelements);
     94  ResetVector (Xvec, OPIHI_FLT, Ntars);
     95  ResetVector (Yvec, OPIHI_FLT, Ntars);
     96  ResetVector (Zvec, OPIHI_FLT, Ntars);
    10097  ALLOCATE (buffer, char, (BLOCK*BYTES_STAR));
    10198

  • branches/eam_branch_20081124/Ohana/src/opihi/dvo/skycat.c

    r20857 r20859  
    5353  Rmid = 0.5*(Rmin + Rmax);
    5454
     55  Npts = 0;
    5556  NPTS = 200;
    56   ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
    57   ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    58   Npts = 0;
     57  ResetVector (&Xvec, OPIHI_FLT, NPTS);
     58  ResetVector (&Yvec, OPIHI_FLT, NPTS);
    5959   
    6060  regions = skylist[0].regions;

  • branches/eam_branch_20081124/Ohana/src/opihi/lib.data/graphtools.c

    r20856 r20859  
    22
    33// XXX need to select the active vector for the range analysis
     4// this function accepts either FLT or INT vectors
    45void SetLimits (Vector *xvec, Vector *yvec, Graphdata *graphmode) {
    56

  • branches/eam_branch_20081124/Ohana/src/opihi/lib.shell/VectorOps.c

    r20856 r20859  
    187187}
    188188
     189// recast the vector to the specified type
     190int CastVector (Vector *vec, char type) {
     191
     192  // the trivial case
     193  if (vec[0].type == type) return TRUE;
     194
     195  if (type == OPIHI_FLT) {
     196    opihi_flt *temp;
     197    ALLOCATE (temp, opihi_flt, vec[0].Nelements);
     198    opihi_flt *vo = temp;
     199    opihi_int *vi = vec[0].elements.Int;
     200    for (i = 0; i < vec[0].Nelements; i++, vo++, vi++) {
     201      *vo = *vi;
     202    }
     203    free (vec[0].elements.Int);
     204    vec[0].elements.Flt = vo;
     205    vec[0].type = OPIHI_FLT;
     206  } else {
     207    opihi_int *temp;
     208    ALLOCATE (temp, opihi_int, vec[0].Nelements);
     209    opihi_int *vo = temp;
     210    opihi_flt *vi = vec[0].elements.Flt;
     211    for (i = 0; i < vec[0].Nelements; i++, vo++, vi++) {
     212      *vo = *vi;
     213    }
     214    free (vec[0].elements.Flt);
     215    vec[0].elements.Int = vo;
     216    vec[0].type = OPIHI_INT;
     217  }
     218  return TRUE;
     219}
     220
    189221/* move data from in to out - use old memory space */
    190222int MoveNamedVector (char *out, char *in) {

  • branches/eam_branch_20081124/Ohana/src/opihi/mana/fitcontour.c

    r20856 r20859  
    1919
    2020  // require these to be float vectors
    21   if (vecx->type != OPIHI_FLT) return (FALSE);
    22   if (vecy->type != OPIHI_FLT) return (FALSE);
     21  REQUIRE_VECTOR_FLT (vecx, FALSE);
     22  REQUIRE_VECTOR_FLT (vecy, FALSE);
    2323
    2424  ALLOCATE (B, double *, NTERM);

  • branches/eam_branch_20081124/Ohana/src/opihi/mana/rawstars.c

    r20856 r20859  
    6666  v = (float *) buff[0].matrix.buffer;
    6767  for (i = 0; i < Np; i++) {
    68     x = xp[0].elements.Flt[i];
    69     y = yp[0].elements.Flt[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];
    7070    if (x < 0) continue;
    7171    if (x >= Nx) continue;
Note: See TracChangeset for help on using the changeset viewer.