IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 20839


Ignore:
Timestamp:
Nov 25, 2008, 4:51:39 PM (17 years ago)
Author:
eugene
Message:

convert opihi vectors to double type, add option for int type as well

Location:
branches/eam_branch_20081124/Ohana/src/opihi
Files:
126 edited

Legend:

Unmodified
Added
Removed

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

    r7917 r20839  
    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
    … …  
    9192  if (!NoVector) {
    9293    xvec[0].Nelements = yvec[0].Nelements = nlong;
    93     REALLOCATE (xvec[0].elements, float, nlong);
    94     REALLOCATE (yvec[0].elements, float, nlong);
     94    REALLOCATE (xvec[0].elements.Flt, opihi_flt, nlong);
     95    REALLOCATE (yvec[0].elements.Flt, opihi_flt, nlong);
    9596    for (i = 0; i < nlong; i++) {
    96       xvec[0].elements[i] = i + start;
    97       yvec[0].elements[i] = vect[i];
     97      xvec[0].elements.Flt[i] = i + start;
     98      yvec[0].elements.Flt[i] = vect[i];
    9899    }
    99100  }

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

    r13479 r20839  
    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
    … …  
    9696  /* prepare vectors to hold data */
    9797  NELEMENTS = 200;
    98   ALLOCATE (Xvec.elements, float, NELEMENTS);
    99   ALLOCATE (Yvec.elements, float, NELEMENTS);
     98  ALLOCATE (Xvec.elements.Flt, opihi_flt, NELEMENTS);
     99  ALLOCATE (Yvec.elements.Flt, opihi_flt, NELEMENTS);
    100100  N = 0;
    101101 
    … …  
    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, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
     394
     395  free (Xvec.elements.Flt);
     396  free (Yvec.elements.Flt);
    397397  return (TRUE);
    398398

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

    r17484 r20839  
    8989  if (mode == SKY) {
    9090    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);
     91      XY_to_RD (&xvec[0].elements.Flt[i], &yvec[0].elements.Flt[i], xvec[0].elements.Flt[i], yvec[0].elements.Flt[i], &coords);
    9292    }
    9393    return (TRUE);
    … …  
    9595  if (mode == PIXEL) {
    9696    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);
     97      RD_to_XY (&xvec[0].elements.Flt[i], &yvec[0].elements.Flt[i], xvec[0].elements.Flt[i], yvec[0].elements.Flt[i], &coords);
    9898    }
    9999    return (TRUE);

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

    r19823 r20839  
    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;
    … …  
    2828  }
    2929
    30   ALLOCATE (Xvec.elements, float, xvec[0].Nelements);
    31   ALLOCATE (Yvec.elements, float, xvec[0].Nelements);
     30  ALLOCATE (Xvec.elements.Flt, opihi_flt, xvec[0].Nelements);
     31  ALLOCATE (Yvec.elements.Flt, opihi_flt, xvec[0].Nelements);
    3232   
    3333  Xvec.Nelements = xvec[0].Nelements;
    3434  Yvec.Nelements = 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;
    … …  
    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, Npts, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    8080 
    81   free (Xvec.elements);
    82   free (Yvec.elements);
     81  free (Xvec.elements.Flt);
     82  free (Yvec.elements.Flt);
    8383   
    8484  return (TRUE);

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

    r16935 r20839  
    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  xptr = xvec[0].elements.Flt;
     57  yptr = yvec[0].elements.Flt;
    5858
    5959  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;
     60    ApplyTransform (xptr, yptr, *xptr, *yptr, transform);
    6461  }
    6562

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

    r19823 r20839  
    55  int i, kapa, Npts;
    66  double min, range, Rmin, Rmax;
    7   float *in, *out, *r, *d, *x, *y;
     7  opihi_flt *in, *out, *r, *d, *x, *y;
    88  Vector Xvec, Yvec, Zvec, *xvec, *yvec, *zvec;
    99  Graphdata graphmode;
    … …  
    3737  Yvec.Nelements = xvec[0].Nelements;
    3838  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);
     39  ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     40  ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     41  ALLOCATE (Zvec.elements.Flt, opihi_flt, Zvec.Nelements);
    4242 
    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;
     43  r   = xvec[0].elements.Flt;
     44  d   = yvec[0].elements.Flt;
     45  in  = zvec[0].elements.Flt;
     46  x   = Xvec.elements.Flt;
     47  y   = Yvec.elements.Flt;
     48  out = Zvec.elements.Flt;
    4949  for (i = 0; i < Zvec.Nelements; i++, in++, out++, r++, d++, x++, y++) {
    5050    *out = MIN (1.0, MAX (0.01, (*in - min) / range));
    5151    *r = ohana_normalize_angle (*r);
    52     fRD_to_XY (x, y, *r, *d, &graphmode.coords);
     52    RD_to_XY (x, y, *r, *d, &graphmode.coords);
    5353  }
    5454
    … …  
    5757  graphmode.etype = 0;
    5858  Npts = Xvec.Nelements;
    59   PlotVectorTriplet (kapa, Npts, Xvec.elements, Yvec.elements, Zvec.elements, &graphmode);
     59  PlotVectorTriplet (kapa, Npts, Xvec.elements.Flt, Yvec.elements.Flt, Zvec.elements.Flt, &graphmode);
    6060
    61   free (Xvec.elements);
    62   free (Yvec.elements);
    63   free (Zvec.elements);
     61  free (Xvec.elements.Flt);
     62  free (Yvec.elements.Flt);
     63  free (Zvec.elements.Flt);
    6464
    6565  return (TRUE);

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

    r3144 r20839  
    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];

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

    r12840 r20839  
    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) */

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

    r3144 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r12840 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r4420 r20839  
    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; */

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

    r3144 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r12840 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r3144 r20839  
    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];

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

    r12840 r20839  
    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;

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

    r16059 r20839  
    7272            v = 0;
    7373            for (n = 0; n < Nwo[i-1][0].Nelements; n++) {
    74               v += -pow (Nwo[i-1][0].elements[n], (double)(j+J));
     74              v += -pow (Nwo[i-1][0].elements.Flt[n], (double)(j+J));
    7575            }
    7676            a[Ny][Nx] = v;
    … …  
    8383            v = 0;
    8484            for (n = 0; n < Nwo[i][0].Nelements; n++) {
    85               v += -pow (Nwo[i][0].elements[n], (double)(j+J));
     85              v += -pow (Nwo[i][0].elements.Flt[n], (double)(j+J));
    8686            }
    8787            a[Ny][Nx] = v;
    … …  
    9494            v = 0;
    9595            for (n = 0; n < Nwb[i][0].Nelements; n++) {
    96               v += pow (Nwb[i][0].elements[n], (double)(j+J));
     96              v += pow (Nwb[i][0].elements.Flt[n], (double)(j+J));
    9797            }
    9898            if (i > 0) {
    9999              for (n = 0; n < Nwo[i-1][0].Nelements; n++) {
    100                 v += pow (Nwo[i-1][0].elements[n], (double)(j+J));
     100                v += pow (Nwo[i-1][0].elements.Flt[n], (double)(j+J));
    101101              }
    102102            }
    103103            if (i < Norder - 1) {
    104104              for (n = 0; n < Nwo[i][0].Nelements; n++) {
    105                 v += pow (Nwo[i][0].elements[n], (double)(j+J));
     105                v += pow (Nwo[i][0].elements.Flt[n], (double)(j+J));
    106106              }
    107107            }
    … …  
    123123      v = 0;
    124124      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);
     125        v += NMb[i][0].elements.Flt[n]*pow (Nwb[i][0].elements.Flt[n], (double)j);
     126        v -= Nmb[i][0].elements.Flt[n]*pow (Nwb[i][0].elements.Flt[n], (double)j);
    127127      }
    128128      if (i > 0) {
    129129        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);
     130          v += Nmh[i-1][0].elements.Flt[n] * pow (Nwo[i-1][0].elements.Flt[n], (double)j);
     131          v -= Nml[i-1][0].elements.Flt[n] * pow (Nwo[i-1][0].elements.Flt[n], (double)j);
    132132        }
    133133      }
    134134      if (i < Norder - 1) {
    135135        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);
     136          v += Nml[i][0].elements.Flt[n] * pow (Nwo[i][0].elements.Flt[n], (double)j);
     137          v -= Nmh[i][0].elements.Flt[n] * pow (Nwo[i][0].elements.Flt[n], (double)j);
    138138        }
    139139      }
    … …  
    146146  for (i = 0; i < Norder; i++) {
    147147    Nc[i][0].Nelements = nterm[i];
    148     REALLOCATE (Nc[i][0].elements, float, nterm[i]);
     148    REALLOCATE (Nc[i][0].elements.Flt, opihi_flt, nterm[i]);
    149149    for (j = 0; j < nterm[i]; j++, Ny++) {
    150       Nc[i][0].elements[j] = b[Ny][0];
     150      Nc[i][0].elements.Flt[j] = b[Ny][0];
    151151    }
    152152  }

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

    r7917 r20839  
    9191 
    9292  for (i = 0; i < xvec[0].Nelements; i++) {
    93     A = xvec[0].elements[i];
    94     D = yvec[0].elements[i];
     93    A = xvec[0].elements.Flt[i];
     94    D = yvec[0].elements.Flt[i];
    9595    SD =  cos(RAD_DEG*A + zeta)*sin(theta)*cos(RAD_DEG*D) + cos(theta)*sin(RAD_DEG*D);
    9696    CD = sqrt (1 - SD*SD);
    … …  
    104104      RA += 360;
    105105   
    106     xvec[0].elements[i] = RA;
    107     yvec[0].elements[i] = DEC;
     106    xvec[0].elements.Flt[i] = RA;
     107    yvec[0].elements.Flt[i] = DEC;
    108108  }
    109109

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

    r7917 r20839  
    2929
    3030  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);
     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));
     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);

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

    r7917 r20839  
    5555
    5656  N = y2 - y1;
    57   REALLOCATE (xvec[0].elements, float, N);
    58   REALLOCATE (yvec[0].elements, float, N);
     57  REALLOCATE (xvec[0].elements.Flt, opihi_flt, N);
     58  REALLOCATE (yvec[0].elements.Flt, opihi_flt, N);
    5959  xvec[0].Nelements = N;
    6060  yvec[0].Nelements = N;
    … …  
    103103      R += 1.0 / sky2;
    104104    }
    105     xvec[0].elements[j] = j + y1;
    106     yvec[0].elements[j] = F / R;
     105    xvec[0].elements.Flt[j] = j + y1;
     106    yvec[0].elements.Flt[j] = F / R;
    107107    gprint (GP_ERR, " %5.1f %7.1f  %6.2f\n", sky, sky2, (F/R));
    108108  }   

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

    r7917 r20839  
    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
    … …  
    4647
    4748  out[0].Nelements = Nbins;
    48   REALLOCATE (out[0].elements, float, out[0].Nelements);
    49   bzero (out[0].elements, sizeof(float)*out[0].Nelements);
     49  REALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
     50  bzero (out[0].elements.Flt, sizeof(opihi_flt)*out[0].Nelements);
    5051  if (Normalize) {
    51     ALLOCATE (NV, float, Nbins);
    52     bzero (NV, sizeof(float)*Nbins);
     52    ALLOCATE (NV, int, Nbins);
     53    bzero (NV, sizeof(int)*Nbins);
    5354  }
    5455
    55   V = val[0].elements;
    56   K = key[0].elements;
    57   O = out[0].elements;
     56  V = val[0].elements.Flt;
     57  K = key[0].elements.Flt;
     58  O = out[0].elements.Flt;
    5859
    5960  for (i = 0; i < val[0].Nelements; i++, V++, K++) {

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

    r16428 r20839  
    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 *x, *y;
    119  Vector *xvec, *yvec;
    1210
    … …  
    3937  }
    4038  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;
     39  REALLOCATE (yvec[0].elements.Flt, opihi_flt, yvec[0].Nelements);
     40  bzero (yvec[0].elements.Flt, sizeof(opihi_flt)*yvec[0].Nelements);
     41  x = xvec[0].elements.Flt;
     42  y = yvec[0].elements.Flt;
    4543
    4644  for (j = 0; j < xvec[0].Nelements; j++, x++, y++) {

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

    r16428 r20839  
    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 *x, *y, *z;
    119  Vector *xvec, *yvec, *zvec;
    1210
    … …  
    4644
    4745  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;
     46  REALLOCATE (zvec[0].elements.Flt, opihi_flt, zvec[0].Nelements);
     47  bzero (zvec[0].elements.Flt, sizeof(opihi_flt)*zvec[0].Nelements);
     48  x = xvec[0].elements.Flt;
     49  y = yvec[0].elements.Flt;
     50  z = zvec[0].elements.Flt;
    5351
    5452  for (n = 0; n < xvec[0].Nelements; n++, x++, y++, z++) {

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

    r8131 r20839  
    1919    Nin = ovec[0].Nelements;
    2020    ovec[0].Nelements++;
    21     REALLOCATE (ovec[0].elements, float, ovec[0].Nelements);
    22     ovec[0].elements[Nin] = value;
     21    REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements);
     22    ovec[0].elements.Flt[Nin] = value;
    2323    return (TRUE);
    2424  }
    … …  
    2626  if ((ivec = SelectVector (argv[1], OLDVECTOR, TRUE)) == NULL) return (FALSE);
    2727 
    28   REALLOCATE (ovec[0].elements, float, ovec[0].Nelements + ivec[0].Nelements);
     28  REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements + ivec[0].Nelements);
    2929  for (j = ovec[0].Nelements, i = 0; i < ivec[0].Nelements; i++, j++) {
    30     ovec[0].elements[j] = ivec[0].elements[i];
     30    ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
    3131  }
    3232  ovec[0].Nelements += ivec[0].Nelements;

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

    r7917 r20839  
    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  REALLOCATE (xv[0].elements.Flt, opihi_flt, NVEC);
     95  REALLOCATE (yv[0].elements.Flt, opihi_flt, NVEC);
    9796
    9897  for (j = 1; j < Ny; j++) {

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

    r12332 r20839  
    2828
    2929  vec[0].Nelements = (end - start) / delta;
    30   REALLOCATE (vec[0].elements, float, vec[0].Nelements);
     30  REALLOCATE (vec[0].elements.Flt, opihi_flt, vec[0].Nelements);
    3131
    3232  for (i = 0; i < vec[0].Nelements; i++) {
    33     vec[0].elements[i] = start + i*delta;
     33    vec[0].elements.Flt[i] = start + i*delta;
    3434  }
    3535

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

    r10307 r20839  
    44 
    55  int i;
    6   float *Vi, *Vo;
     6  opihi_flt *Vi, *Vo;
    77  Vector *ivec, *ovec;
    88
    … …  
    1616  ovec[0].Nelements = ivec[0].Nelements;
    1717   
    18   REALLOCATE (ovec[0].elements, float, ovec[0].Nelements);
    19   bzero (ovec[0].elements, sizeof(float)*ovec[0].Nelements);
     18  REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements);
     19  bzero (ovec[0].elements.Flt, sizeof(opihi_flt)*ovec[0].Nelements);
    2020
    21   Vi = ivec[0].elements;
    22   Vo = ovec[0].elements;
     21  Vi = ivec[0].elements.Flt;
     22  Vo = ovec[0].elements.Flt;
    2323  *Vo = *Vi;
    2424  for (i = 1; i < ivec[0].Nelements; i++, Vi++, Vo++) {

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

    r16446 r20839  
    4949    /* create output vectors */
    5050    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));
     51    REALLOCATE (xvec[0].elements.Flt, opihi_flt, MAX (nx, 1));
     52    REALLOCATE (yvec[0].elements.Flt, opihi_flt, MAX (nx, 1));
     53    bzero (yvec[0].elements.Flt, nx*sizeof(opihi_flt));
    5454    for (i = 0; i < nx; i++) {
    55       xvec[0].elements[i] = i + sx;
     55      xvec[0].elements.Flt[i] = i + sx;
    5656    }
    5757    ALLOCATE (Vbuf, float, MAX (ny, 1));
    … …  
    7474        if (Mode == MEAN) { value /= ny; }
    7575      }
    76       yvec[0].elements[i] = value;
     76      yvec[0].elements.Flt[i] = value;
    7777    }
    7878    free (Vbuf);
    … …  
    8282  case 'Y':
    8383    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));
     84    REALLOCATE (xvec[0].elements.Flt, opihi_flt, ny);
     85    REALLOCATE (yvec[0].elements.Flt, opihi_flt, ny);
     86    bzero (yvec[0].elements.Flt, ny*sizeof(opihi_flt));
    8787    for (i = 0; i < ny; i++) {
    88       xvec[0].elements[i] = i + sy;
     88      xvec[0].elements.Flt[i] = i + sy;
    8989    }
    9090    ALLOCATE (Vbuf, float, MAX (nx, 1));
    … …  
    107107        if (Mode == MEAN) { value /= nx; }
    108108      }
    109       yvec[0].elements[i] = value;
     109      yvec[0].elements.Flt[i] = value;
    110110    }
    111111    free (Vbuf);

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

    r17852 r20839  
    6767      return (FALSE);
    6868    }
    69     REALLOCATE (vec[i][0].elements, float, Nrows);
     69    REALLOCATE (vec[i][0].elements.Flt, opihi_flt, Nrows);
    7070    vec[i][0].Nelements = Nrows;
    7171  }
    … …  
    9191          case FIELD_TYPE_FLOAT:
    9292          case FIELD_TYPE_DOUBLE:
    93             vec[i][0].elements[j] = atof (row[i]);
     93            vec[i][0].elements.Flt[j] = atof (row[i]);
    9494            break;
    9595          case FIELD_TYPE_TIME:
    … …  
    9797          case FIELD_TYPE_DATETIME:
    9898            seconds = ohana_date_to_sec (row[i]);
    99             vec[i][0].elements[j] = ohana_sec_to_mjd (seconds);
     99            vec[i][0].elements.Flt[j] = ohana_sec_to_mjd (seconds);
    100100            break;
    101101          default:
    102             vec[i][0].elements[j] = NAN;
     102            vec[i][0].elements.Flt[j] = NAN;
    103103        }
    104104      } else {
    105         vec[i][0].elements[j] = NAN;
     105        vec[i][0].elements.Flt[j] = NAN;
    106106      }
    107107    }

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

    r7917 r20839  
    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;
    … …  
    3031
    3132  vec[0].Nelements = Npix;
    32   REALLOCATE (vec[0].elements, float, Npix);
     33  REALLOCATE (vec[0].elements.Flt, opihi_flt, Npix);
    3334
    3435  in = (float *) buf[0].matrix.buffer;
    35   out = vec[0].elements;
     36  out = vec[0].elements.Flt;
    3637
    3738  switch (mode) {

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

    r9275 r20839  
    44 
    55  int i, Nx, Ny, Npix;
    6   float *in, *out;
     6  opihi_flt *in;
     7  float *out;
    78  Vector *vec;
    89  Buffer *buf;
    … …  
    2930
    3031  out = (float *) buf[0].matrix.buffer;
    31   in = vec[0].elements;
     32  in = vec[0].elements.Flt;
    3233
    3334  for (i = 0; i < Npix; i++, in++, out++) {

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

    r16107 r20839  
    4343  Ore[0].Nelements = Npix;
    4444  Oim[0].Nelements = Npix;
    45   REALLOCATE (Ore[0].elements, float, Npix);
    46   REALLOCATE (Oim[0].elements, float, Npix);
     45  REALLOCATE (Ore[0].elements.Flt, opihi_flt, Npix);
     46  REALLOCATE (Oim[0].elements.Flt, opihi_flt, Npix);
    4747 
    4848  // copy data to output vectors (fft is done in place)
    49   memcpy (Ore[0].elements, Ire[0].elements, Npix*sizeof(float));
     49  memcpy (Ore[0].elements.Flt, Ire[0].elements.Flt, Npix*sizeof(opihi_flt));
    5050
    5151  // copy imaginary vector or create a zero vector
    5252  if (ZeroImaginary) {
    53     memset (Oim[0].elements, 0, Npix*sizeof(float));
     53    memset (Oim[0].elements.Flt, 0, Npix*sizeof(opihi_flt));
    5454  } else {
    55     memcpy (Oim[0].elements, Iim[0].elements, Npix*sizeof(float));
     55    memcpy (Oim[0].elements.Flt, Iim[0].elements.Flt, Npix*sizeof(opihi_flt));
    5656  }   
    5757
    58   fft1D (Ore[0].elements, Oim[0].elements, Npix, Nbit, forward);
     58  dfft1D (Ore[0].elements.Flt, Oim[0].elements.Flt, Npix, Nbit, forward);
    5959 
    6060  return (TRUE);

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

    r16059 r20839  
    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
    … …  
    6363  mterm = 2*nterm;
    6464
    65   ALLOCATE (yfit, float, xvec[0].Nelements);
     65  ALLOCATE (yfit, opihi_flt, xvec[0].Nelements);
    6666  ALLOCATE (mask, char, xvec[0].Nelements);
    6767  memset (mask, 0, xvec[0].Nelements);
    … …  
    8888
    8989    /* perform linear fit */
    90     x = xvec[0].elements;
    91     y = yvec[0].elements;
    92     if (Weight) dy = dyvec[0].elements;
     90    x = xvec[0].elements.Flt;
     91    y = yvec[0].elements.Flt;
     92    if (Weight) dy = dyvec[0].elements.Flt;
    9393
    9494    for (i = 0; i < xvec[0].Nelements; i++, x++, y++) {
    … …  
    121121
    122122    /* generate fitted values */
    123     x = xvec[0].elements;
     123    x = xvec[0].elements.Flt;
    124124    yf = yfit;
    125125    for (i = 0; i < xvec[0].Nelements; i++, x++, yf++) {
    … …  
    134134
    135135    /* measure fit residual scatter */
    136     x  = xvec[0].elements;
    137     y  = yvec[0].elements;
     136    x  = xvec[0].elements.Flt;
     137    y  = yvec[0].elements.Flt;
    138138    yf = yfit;
    139139    dY = dY2 = 0;
    … …  
    150150
    151151    /* mask outlier points */
    152     x  = xvec[0].elements;
    153     y  = yvec[0].elements;
     152    x  = xvec[0].elements.Flt;
     153    y  = yvec[0].elements.Flt;
    154154    yf = yfit;
    155155    Nmask = 0;
    … …  
    193193    if ((fvec = SelectVector ("yfit", ANYVECTOR, TRUE)) == NULL) return (FALSE);   
    194194    if ((mvec = SelectVector ("mask", ANYVECTOR, TRUE)) == NULL) return (FALSE);   
    195     free (fvec[0].elements);
    196     fvec[0].elements = yfit;
     195    free (fvec[0].elements.Flt);
     196    fvec[0].elements.Flt = yfit;
    197197    fvec[0].Nelements = xvec[0].Nelements;
    198198    mvec[0].Nelements = xvec[0].Nelements;
    199199
    200     REALLOCATE (mvec[0].elements, float, xvec[0].Nelements);
     200    REALLOCATE (mvec[0].elements.Flt, opihi_flt, xvec[0].Nelements);
    201201    for (i = 0; i < xvec[0].Nelements; i++) {
    202       mvec[0].elements[i] = mask[i];
     202      mvec[0].elements.Flt[i] = mask[i];
    203203    }
    204204  } else {

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

    r16059 r20839  
    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;
    … …  
    7474  mterm = 2*order + 1;
    7575
    76   ALLOCATE (zfit, float, xvec[0].Nelements);
     76  ALLOCATE (zfit, opihi_flt, xvec[0].Nelements);
    7777  ALLOCATE (mask, char, xvec[0].Nelements);
    7878  memset (mask, 0, xvec[0].Nelements);
    … …  
    102102    }
    103103
    104     x = xvec[0].elements;
    105     y = yvec[0].elements;
    106     z = zvec[0].elements;
    107     if (Weight) dz = dzvec[0].elements;
     104    x = xvec[0].elements.Flt;
     105    y = yvec[0].elements.Flt;
     106    z = zvec[0].elements.Flt;
     107    if (Weight) dz = dzvec[0].elements.Flt;
    108108
    109109    /* add up the x,y values */
    … …  
    128128
    129129    /* add up the z values */
    130     x = xvec[0].elements;
    131     y = yvec[0].elements;
    132     z = zvec[0].elements;
     130    x = xvec[0].elements.Flt;
     131    y = yvec[0].elements.Flt;
     132    z = zvec[0].elements.Flt;
    133133    for (i = 0; i < xvec[0].Nelements; i++, x++, y++, z++) {
    134134      if (mask[i]) continue;
    … …  
    179179    */
    180180    /* generate fitted values */
    181     x = xvec[0].elements;
    182     y = yvec[0].elements;
     181    x = xvec[0].elements.Flt;
     182    y = yvec[0].elements.Flt;
    183183    zf = zfit;
    184184    for (n = 0; n < xvec[0].Nelements; n++, x++, y++, zf++) {
    … …  
    197197
    198198    /* measure fit residual scatter */
    199     x  = xvec[0].elements;
    200     y  = yvec[0].elements;
    201     z  = zvec[0].elements;
     199    x  = xvec[0].elements.Flt;
     200    y  = yvec[0].elements.Flt;
     201    z  = zvec[0].elements.Flt;
    202202    zf = zfit;
    203203    dZ = dZ2 = 0;
    … …  
    216216
    217217    /* mask outlier points */
    218     x  = xvec[0].elements;
    219     y  = yvec[0].elements;
    220     z  = zvec[0].elements;
     218    x  = xvec[0].elements.Flt;
     219    y  = yvec[0].elements.Flt;
     220    z  = zvec[0].elements.Flt;
    221221    zf = zfit;
    222222    Nmask = 0;

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

    r7917 r20839  
    1616
    1717  vec[0].Nelements = Npts;
    18   REALLOCATE (vec[0].elements, float, Npts);
     18  REALLOCATE (vec[0].elements.Flt, opihi_flt, Npts);
    1919
    2020  gauss_init (2048);
    2121  for (i = 0; i < Npts; i++) {
    22     vec[0].elements[i] = rnd_gauss (mean, sigma);
     22    vec[0].elements.Flt[i] = rnd_gauss (mean, sigma);
    2323  }
    2424  return (TRUE);
    … …  
    4747
    4848  vec[0].Nelements = Npts;
    49   REALLOCATE (vec[0].elements, float, Npts);
     49  REALLOCATE (vec[0].elements.Flt, opihi_flt, Npts);
    5050
    5151  gauss_init (Npts);
    5252  for (i = 0; i < Npts; i++) {
    53     vec[0].elements[i] = int_gauss (i);
     53    vec[0].elements.Flt[i] = int_gauss (i);
    5454  }
    5555  return (TRUE);

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

    r16117 r20839  
    22
    33int gaussjordan (int argc, char **argv) {
    4  
    5   float *m, *v;
     4
     5  float *m;
     6  opihi_flt *v;
    67  double **a, **b;
    78  int i, j, N, status, QUIET;
    … …  
    3233
    3334  m = (float *) A[0].matrix.buffer;
    34   v = B[0].elements;
     35  v = B[0].elements.Flt;
    3536  for (i = 0; i < N; i++) {
    3637    for (j = 0; j < N; j++) {

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

    r13479 r20839  
    2525  Xvec.Nelements = 200;
    2626  Yvec.Nelements = 200;
    27   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    28   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
     27  ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     28  ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    2929
    3030  major = minor = 1;
    … …  
    6464      if (MajorTick) {
    6565        /* 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);
     66        Xvec.elements.Flt[N] = next;
     67        Yvec.elements.Flt[N] = graphmode.ymin;
     68        N++;
     69        if (N == Xvec.Nelements) {
     70          Xvec.Nelements += 200;
     71          Yvec.Nelements += 200;
     72          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     73          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     74        }
     75        Xvec.elements.Flt[N] = next;
     76        Yvec.elements.Flt[N] = graphmode.ymax;
     77        N++;
     78        if (N == Xvec.Nelements) {
     79          Xvec.Nelements += 200;
     80          Yvec.Nelements += 200;
     81          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     82          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    8383        }
    8484      }
    … …  
    8686      if (MinorTick) {
    8787        /* 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);
     88        Xvec.elements.Flt[N] = next;
     89        Yvec.elements.Flt[N] = graphmode.ymin;
     90        N++;
     91        if (N == Xvec.Nelements) {
     92          Xvec.Nelements += 200;
     93          Yvec.Nelements += 200;
     94          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     95          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     96        }
     97        Xvec.elements.Flt[N] = next;
     98        Yvec.elements.Flt[N] = graphmode.ymax;
     99        N++;
     100        if (N == Xvec.Nelements) {
     101          Xvec.Nelements += 200;
     102          Yvec.Nelements += 200;
     103          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     104          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    105105        }
    106106      }
    … …  
    144144      if (MajorTick) {
    145145        /* 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);
     146        Xvec.elements.Flt[N] = graphmode.xmin;
     147        Yvec.elements.Flt[N] = next;
     148        N++;
     149        if (N == Xvec.Nelements) {
     150          Xvec.Nelements += 200;
     151          Yvec.Nelements += 200;
     152          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     153          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     154        }
     155        Xvec.elements.Flt[N] = graphmode.xmax;
     156        Yvec.elements.Flt[N] = next;
     157        N++;
     158        if (N == Xvec.Nelements) {
     159          Xvec.Nelements += 200;
     160          Yvec.Nelements += 200;
     161          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     162          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    163163        }
    164164      }
    … …  
    166166      if (MinorTick) {
    167167        /* 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);
     168        Xvec.elements.Flt[N] = graphmode.xmin;
     169        Yvec.elements.Flt[N] = next;
     170        N++;
     171        if (N == Xvec.Nelements) {
     172          Xvec.Nelements += 200;
     173          Yvec.Nelements += 200;
     174          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     175          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
     176        }
     177        Xvec.elements.Flt[N] = graphmode.xmax;
     178        Yvec.elements.Flt[N] = next;
     179        N++;
     180        if (N == Xvec.Nelements) {
     181          Xvec.Nelements += 200;
     182          Yvec.Nelements += 200;
     183          REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     184          REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    185185        }
    186186      }
    … …  
    193193  graphmode.ptype = 100; /* connect a pair */
    194194  graphmode.etype = 0;
    195   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
    196 
    197   free (Xvec.elements);
    198   free (Yvec.elements);
     195  PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
     196
     197  free (Xvec.elements.Flt);
     198  free (Yvec.elements.Flt);
    199199
    200200  return (TRUE);

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

    r9275 r20839  
    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;
    … …  
    5051  bzero (Nval, Nx*Ny*sizeof(int));
    5152
    52   x = vx[0].elements;
    53   y = vy[0].elements;
    54   z = vz[0].elements;
     53  x = vx[0].elements.Flt;
     54  y = vy[0].elements.Flt;
     55  z = vz[0].elements.Flt;
    5556  for (i = 0; i < vx[0].Nelements; i++, x++, y++, z++) {
    5657    Xb = (*x - Xmin) / dX;

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

    r20820 r20839  
    44 
    55  int i, bin, Nbins;
    6   float *V, start, end, delta;
     6  opihi_flt start, end, delta;
     7  opihi_flt *V;
    78  Vector *xvec, *yvec;
    89
    … …  
    3233  yvec[0].Nelements = Nbins;
    3334   
    34   REALLOCATE (yvec[0].elements, float, yvec[0].Nelements);
    35   bzero (yvec[0].elements, sizeof(float)*yvec[0].Nelements);
     35  REALLOCATE (yvec[0].elements.Flt, opihi_flt, yvec[0].Nelements);
     36  bzero (yvec[0].elements.Flt, sizeof(opihi_flt)*yvec[0].Nelements);
    3637  if (Nbins < 1) {
    3738      return (TRUE);
    3839  }
    3940
    40   V = xvec[0].elements;
     41  V = xvec[0].elements.Flt;
    4142  for (i = 0; i < xvec[0].Nelements; i++, V++) {
    4243    if (isnan(*V)) continue;
    4344    bin = MIN (MAX (0, (*V - start) / delta), Nbins - 1);
    44     yvec[0].elements[bin] += 1.0;
     45    yvec[0].elements.Flt[bin] += 1.0;
    4546  }     
    4647

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

    r7917 r20839  
    3737  dY = dY / L;
    3838
    39   REALLOCATE (xvec[0].elements, float, MAX (L, 1));
    40   REALLOCATE (yvec[0].elements, float, MAX (L, 1));
     39  REALLOCATE (xvec[0].elements.Flt, opihi_flt, MAX (L, 1));
     40  REALLOCATE (yvec[0].elements.Flt, opihi_flt, MAX (L, 1));
    4141  xvec[0].Nelements = L;
    4242  yvec[0].Nelements = L;
    … …  
    4646    xi = xs + i*dX - 0.5;
    4747    yi = ys + i*dY - 0.5;
    48     xvec[0].elements[i] = i;
    49     yvec[0].elements[i] = V[xi + Nx*yi];
     48    xvec[0].elements.Flt[i] = i;
     49    yvec[0].elements.Flt[i] = V[xi + Nx*yi];
    5050  }
    5151

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

    r16429 r20839  
    107107  vec1[0].Nelements = Nbins + 1;
    108108  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));
     109  REALLOCATE (vec1[0].elements.Flt, opihi_flt, vec1[0].Nelements);
     110  bzero (vec1[0].elements.Flt, vec1[0].Nelements*sizeof(opihi_flt));
     111  REALLOCATE (vec2[0].elements.Flt, opihi_flt, vec2[0].Nelements);
     112  bzero (vec2[0].elements.Flt, vec2[0].Nelements*sizeof(opihi_flt));
    113113 
    114114  for (j = sy; j < sy + ny; j++) {
    … …  
    116116    for (i = 0; i < nx; i++, V++) {
    117117      bin = MAX (MIN (Nbins, (*V - min) / dx), 0);
    118       vec2[0].elements[bin] += 1.0;
     118      vec2[0].elements.Flt[bin] += 1.0;
    119119    }
    120120  }
    121121  for (i = 0; i < Nbins + 1; i++, V++) {
    122     vec1[0].elements[i] = i*dx + min;
     122    vec1[0].elements.Flt[i] = i*dx + min;
    123123  }
    124124 

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

    r7917 r20839  
    44 
    55  int i, N, VERBOSE;
    6   float *X, *Y;
     6  opihi_flt *X, *Y;
    77  double start, end, value, range;
    88  Vector *vecx, *vecy;
    … …  
    2525  end   = atof (argv[4]);
    2626
    27   X = vecx[0].elements;
    28   Y = vecy[0].elements;
     27  X = vecx[0].elements.Flt;
     28  Y = vecy[0].elements.Flt;
    2929
    3030  value = 0;

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

    r7917 r20839  
    2222
    2323  yout[0].Nelements = xout[0].Nelements;
    24   REALLOCATE (yout[0].elements, float, yout[0].Nelements);
     24  REALLOCATE (yout[0].elements.Flt, opihi_flt, yout[0].Nelements);
    2525
    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];
     26  dx = xin[0].elements.Flt[1] - xin[0].elements.Flt[0];
     27  dy = yin[0].elements.Flt[1] - yin[0].elements.Flt[0];
     28  x0 = xin[0].elements.Flt[0];
     29  y0 = yin[0].elements.Flt[0];
    3030 
    3131  /* in vectors are sorted, out vectors are not */
    3232  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];
     33    dx = xin[0].elements.Flt[j+1] - xin[0].elements.Flt[j];
     34    dy = yin[0].elements.Flt[j+1] - yin[0].elements.Flt[j];
     35    x0 = xin[0].elements.Flt[j];
     36    y0 = yin[0].elements.Flt[j];
     37    x1 = xin[0].elements.Flt[j+1];
    3838    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;
     39      if ((xout[0].elements.Flt[i] >= x0) && (xout[0].elements.Flt[i] < x1)) {
     40        yout[0].elements.Flt[i] = (dy/dx)*(xout[0].elements.Flt[i] - x0) + y0;
    4141      }
    42       if ((j == 0) && (xout[0].elements[i] < x0)) {
    43         yout[0].elements[i] = (dy/dx)*(xout[0].elements[i] - x0) + y0;
     42      if ((j == 0) && (xout[0].elements.Flt[i] < x0)) {
     43        yout[0].elements.Flt[i] = (dy/dx)*(xout[0].elements.Flt[i] - x0) + y0;
    4444      }
    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;
     45      if ((j == xin[0].Nelements - 2) && (xout[0].elements.Flt[i] >= x1)) {
     46        yout[0].elements.Flt[i] = (dy/dx)*(xout[0].elements.Flt[i] - x0) + y0;
    4747      }
    4848    }   

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

    r7952 r20839  
    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
    … …  
    2323
    2424  out[0].Nelements = in[0].Nelements;
    25   REALLOCATE (out[0].elements, float, out[0].Nelements);
     25  REALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
    2626
    27   ip = in[0].elements;
    28   op = out[0].elements;
     27  ip = in[0].elements.Flt;
     28  op = out[0].elements.Flt;
    2929
    3030  for (i = 0; i < in[0].Nelements; i++, ip++, op++) {
    3131    // re-write this using bisection
    32     xp = xv[0].elements;
    33     yp = yv[0].elements;
     32    xp = xv[0].elements.Flt;
     33    yp = yv[0].elements.Flt;
    3434
    3535    for (j = 0; (*ip < *xp) && (j < yv[0].Nelements); j++);

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

    r7917 r20839  
    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
    … …  
    3535
    3636  out[0].Nelements = Nbins;
    37   REALLOCATE (out[0].elements, float, out[0].Nelements);
    38   bzero (out[0].elements, sizeof(float)*out[0].Nelements);
     37  REALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
     38  bzero (out[0].elements.Flt, sizeof(opihi_flt)*out[0].Nelements);
    3939
    4040  /* copy vec and key to temp vectors */
    41   ALLOCATE (tmpvec, float, val[0].Nelements);
    42   ALLOCATE (tmpkey, float, val[0].Nelements);
     41  ALLOCATE (tmpvec, opihi_flt, val[0].Nelements);
     42  ALLOCATE (tmpkey, opihi_flt, val[0].Nelements);
    4343
    44   V = val[0].elements;
    45   K = key[0].elements;
     44  V = val[0].elements.Flt;
     45  K = key[0].elements.Flt;
    4646  V1 = tmpvec;
    4747  K1 = tmpkey;
    … …  
    5353
    5454  /* sort vec and key by key */
    55   fsortpair (tmpkey, tmpvec, Nvalues);
     55  dsortpair (tmpkey, tmpvec, Nvalues);
    5656
    57   O = out[0].elements;
     57  O = out[0].elements.Flt;
    5858  /* find the start and end key for each range */
    5959  N0 = 0;
    … …  
    6767    N1 = j;
    6868    N = N1 - N0;
    69     fsort (&tmpvec[N0], N);
     69    dsort (&tmpvec[N0], N);
    7070    fn = O[i] = 0;
    7171    for (j = N0 + 0.25*N; j < N0 + 0.75*N; j++) {

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

    r7917 r20839  
    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;
    … …  
    3334  if (xdir) {
    3435    vec[0].Nelements = Npix = Nx;
    35     REALLOCATE (vec[0].elements, float, Npix);
     36    REALLOCATE (vec[0].elements.Flt, opihi_flt, Npix);
    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 {
    4747    vec[0].Nelements = Npix = Ny;
    48     REALLOCATE (vec[0].elements, float, Npix);
     48    REALLOCATE (vec[0].elements.Flt, opihi_flt, Npix);
    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 

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

    r7917 r20839  
    44 
    55  int i, Nx, Ny, Npix, xdir, Nset;
    6   float *in, *out;
     6  opihi_flt *in;
     7  float *out;
    78  Buffer *buf;
    89  Vector *vec;
    … …  
    4243    }
    4344    out = (float *) buf[0].matrix.buffer + Nx*Nset;
    44     in = vec[0].elements;
     45    in = vec[0].elements.Flt;
    4546    for (i = 0; i < Npix; i++, in++, out++) {
    4647      *out = *in;
    … …  
    5758    }
    5859    out = (float *) buf[0].matrix.buffer + Nset;
    59     in = vec[0].elements;
     60    in = vec[0].elements.Flt;
    6061    for (i = 0; i < Npix; i++, in++, out+=Nx) {
    6162      *out = *in;

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

    r7917 r20839  
    55  int i, N, imax, QUIET;
    66  double start, end, xmax, ymax;
    7   float *X, *Y;
     7  opihi_flt *X, *Y;
    88  Vector *vecx, *vecy;
    99
    … …  
    2626    end   = atof (argv[4]);
    2727  } else {
    28     start = vecx[0].elements[0];
    29     end   = vecx[0].elements[vecx[0].Nelements - 1];
     28    start = vecx[0].elements.Flt[0];
     29    end   = vecx[0].elements.Flt[vecx[0].Nelements - 1];
    3030  }
    3131
    32   X = vecx[0].elements;
    33   Y = vecy[0].elements;
     32  X = vecx[0].elements.Flt;
     33  Y = vecy[0].elements.Flt;
    3434
    3535  imax = -1;

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

    r7917 r20839  
    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;
    … …  
    2929
    3030  /* find the max baseline, mean, and variance */
    31   minT = maxT = time[0].elements[0];
     31  minT = maxT = time[0].elements.Flt[0];
    3232  Npt = time[0].Nelements;
    33   tv = time[0].elements;
    34   fv = flux[0].elements;
     33  tv = time[0].elements.Flt;
     34  fv = flux[0].elements.Flt;
    3535  mean = var = 0;
    3636  for (i = 0; i < Npt; i++, tv++, fv++) {
    … …  
    4040  }
    4141  mean = mean / Npt;
    42   fv = flux[0].elements;
     42  fv = flux[0].elements.Flt;
    4343  for (i = 0; i < Npt; i++, fv++) {
    4444    var += SQ(*fv - mean);
    … …  
    5656  Np = 0;
    5757  NP = 100;
    58   REALLOCATE (power[0].elements, float, NP);
    59   REALLOCATE (period[0].elements, float, NP);
     58  REALLOCATE (power[0].elements.Flt, opihi_flt, NP);
     59  REALLOCATE (period[0].elements.Flt, opihi_flt, NP);
    6060
    6161  P = minP;
    … …  
    6464   
    6565    /* find the period offset tau  */
    66     tv = time[0].elements;
     66    tv = time[0].elements.Flt;
    6767    cs = sn = 0;
    6868    for (i = 0; i < Npt; i++, tv++) {
    … …  
    7373     
    7474    /* find the power at this period */
    75     tv = time[0].elements;
    76     fv = flux[0].elements;
     75    tv = time[0].elements.Flt;
     76    fv = flux[0].elements.Flt;
    7777    cs = sn = cs2 = sn2 = 0;
    7878    for (i = 0; i < Npt; i++, tv++, fv++) {
    … …  
    9090    Po = (Pc + Ps) / (2*var);
    9191
    92     power[0].elements[Np] = Po;
    93     period[0].elements[Np] = P;
     92    power[0].elements.Flt[Np] = Po;
     93    period[0].elements.Flt[Np] = P;
    9494    Np ++;
    9595    if (Np >= NP) {
    9696      NP += 100;
    97       REALLOCATE (power[0].elements, float, NP);
    98       REALLOCATE (period[0].elements, float, NP);
     97      REALLOCATE (power[0].elements.Flt, opihi_flt, NP);
     98      REALLOCATE (period[0].elements.Flt, opihi_flt, NP);
    9999    }
    100100
    … …  
    108108  power[0].Nelements = Np;
    109109  period[0].Nelements = Np;
    110   REALLOCATE (power[0].elements, float, Np);
    111   REALLOCATE (period[0].elements, float, Np);
     110  REALLOCATE (power[0].elements.Flt, opihi_flt, Np);
     111  REALLOCATE (period[0].elements.Flt, opihi_flt, Np);
    112112 
    113113  return (TRUE);

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

    r13479 r20839  
    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, Npts, xvec[0].elements.Flt, "x");
     61  PlotVectorSingle (kapa, Npts, yvec[0].elements.Flt, "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, Npts, dymvec[0].elements.Flt, "dym");
     64    PlotVectorSingle (kapa, Npts, dypvec[0].elements.Flt, "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, Npts, dxmvec[0].elements.Flt, "dxm");
     68    PlotVectorSingle (kapa, Npts, dxpvec[0].elements.Flt, "dxp");
    6969  }
    7070  return (TRUE);

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

    r17070 r20839  
    8484  NELEM = 1000;
    8585  for (i = 0; i < Nvec; i++) {
    86     REALLOCATE (vec[i][0].elements, float, NELEM);
     86    REALLOCATE (vec[i][0].elements.Flt, opihi_flt, NELEM);
    8787  }
    8888 
    … …  
    121121        for (i = 0; (i < Nvec) && status; i++) {
    122122          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;
     123          vec[i][0].elements.Flt[N] = value;
     124          if (!status) vec[i][0].elements.Flt[N] = 0.0/0.0;
    125125        }
    126126        if (status) N++;
    … …  
    130130        NELEM += 1000;
    131131        for (i = 0; i < Nvec; i++) {
    132           REALLOCATE (vec[i][0].elements, float, NELEM);
     132          REALLOCATE (vec[i][0].elements.Flt, opihi_flt, NELEM);
    133133        }
    134134      }
    … …  
    137137  }
    138138  for (i = 0; i < Nvec; i++) {
    139     REALLOCATE (vec[i][0].elements, float, MAX (N,1));
     139    REALLOCATE (vec[i][0].elements.Flt, opihi_flt, MAX (N,1));
    140140    vec[i][0].Nelements = N;
    141141  }
    … …  
    268268        sprintf (name, "%s:%d", argv[i], j);
    269269      if ((vec[j] = SelectVector (name, ANYVECTOR, TRUE)) == NULL) ESCAPE ("bad vector name");
    270       REALLOCATE (vec[j][0].elements, float, MAX (Ny,1));
     270      REALLOCATE (vec[j][0].elements.Flt, opihi_flt, MAX (Ny,1));
    271271      vec[j][0].Nelements = Ny;
    272272    }
    … …  
    276276      for (j = 0; j < Ny; j++) {
    277277        for (k = 0; k < Nval; k++, Pd++) {
    278           vec[k][0].elements[j] = *Pd;
     278          vec[k][0].elements.Flt[j] = *Pd;
    279279        }
    280280      }
    … …  
    284284      for (j = 0; j < Ny; j++) {
    285285        for (k = 0; k < Nval; k++, Pf++) {
    286           vec[k][0].elements[j] = *Pf;
     286          vec[k][0].elements.Flt[j] = *Pf;
    287287        }
    288288      }
    … …  
    292292      for (j = 0; j < Ny; j++) {
    293293        for (k = 0; k < Nval; k++, Pi++) {
    294           vec[k][0].elements[j] = *Pi;
     294          vec[k][0].elements.Flt[j] = *Pi;
    295295        }
    296296      }
    … …  
    300300      for (j = 0; j < Ny; j++) {
    301301        for (k = 0; k < Nval; k++, Ps++) {
    302           vec[k][0].elements[j] = *Ps;
     302          vec[k][0].elements.Flt[j] = *Ps;
    303303        }
    304304      }
    … …  
    308308      for (j = 0; j < Ny; j++) {
    309309        for (k = 0; k < Nval; k++, Pc++) {
    310           vec[k][0].elements[j] = *Pc;
     310          vec[k][0].elements.Flt[j] = *Pc;
    311311        }
    312312      }

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

    r7917 r20839  
    2727  /* check size of in1, in2, tvec: must match */
    2828
    29   REALLOCATE (ovec[0].elements, float, MAX (tvec[0].Nelements, 1));
     29  REALLOCATE (ovec[0].elements.Flt, opihi_flt, MAX (tvec[0].Nelements, 1));
    3030  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];
     31    ovec[0].elements.Flt[i] = tvec[0].elements.Flt[i] ? in1[0].elements.Flt[i] : in2[0].elements.Flt[i];
    3232  }
    3333  ovec[0].Nelements = tvec[0].Nelements;
    34   REALLOCATE (ovec[0].elements, float, MAX (ovec[0].Nelements, 1));
     34  REALLOCATE (ovec[0].elements.Flt, opihi_flt, MAX (ovec[0].Nelements, 1));
    3535 
    3636  DeleteVector (tvec);

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

    r7917 r20839  
    11# include "data.h"
     2
     3void sortindex (double *X, int *IDX, int N) {
     4
     5# define SWAPFUNC(A,B){ double 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}
    217
    318int sort_vectors (int argc, char **argv) {
    419 
    520  int i, j, Nvec, Nval;
    6   float *temp, *index, *T, *V, *I;
     21  opihi_flt *temp, *T, *V;
     22  int *index, *I;
    723  Vector **vec;
    824
    … …  
    3652 
    3753  /* create index (use float to use sortpair) */
    38   ALLOCATE (index, float, Nval);
     54  ALLOCATE (index, int, Nval);
    3955  for (i = 0; i < Nval; i++) index[i] = i;
    4056
    4157  /* sort key & index */
    42   fsortpair (vec[0][0].elements, index, Nval);
     58  sortindex (vec[0][0].elements.Flt, index, Nval);
    4359
    44   ALLOCATE (temp, float, Nval);
     60  ALLOCATE (temp, opihi_flt, Nval);
    4561  for (i = 1; i < Nvec; i++) {
    4662    T = temp;
    47     V = vec[i][0].elements;
     63    V = vec[i][0].elements.Flt;
    4864    I = index;
    4965    for (j = 0; j < Nval; j++, T++, I++) {
    50       *T = V[(int)(*I)];
     66      *T = V[*I];
    5167    }
    52     /* swap .elements (== V) and temp */
    53     vec[i][0].elements = temp;
     68    /* swap .elements.Flt (== V) and temp */
     69    vec[i][0].elements.Flt = temp;
    5470    temp = V;
    5571  }
    … …  
    6177
    6278}
    63 
    64 

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

    r7917 r20839  
    2828  /* check size of ivec, tvec: must match */
    2929
    30   REALLOCATE (ovec[0].elements, float, MAX (tvec[0].Nelements, 1));
     30  REALLOCATE (ovec[0].elements.Flt, opihi_flt, MAX (tvec[0].Nelements, 1));
    3131  for (j = i = 0; i < tvec[0].Nelements; i++) {
    32     if (tvec[0].elements[i]) {
    33       ovec[0].elements[j] = ivec[0].elements[i];
     32    if (tvec[0].elements.Flt[i]) {
     33      ovec[0].elements.Flt[j] = ivec[0].elements.Flt[i];
    3434      j++;
    3535    }
    3636  }
    3737  ovec[0].Nelements = j;
    38   REALLOCATE (ovec[0].elements, float, MAX (ovec[0].Nelements, 1));
     38  REALLOCATE (ovec[0].elements.Flt, opihi_flt, MAX (ovec[0].Nelements, 1));
    3939
    4040  DeleteVector (tvec);

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

    r7917 r20839  
    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;
    … …  
    4344  /* w is Nx */
    4445  Vw[0].Nelements = Nx;
    45   REALLOCATE (Vw[0].elements, float, Nx);
     46  REALLOCATE (Vw[0].elements.Flt, opihi_flt, Nx);
    4647
    4748  /* pointers to the various arrays */
    4849  A = (float *) Ma[0].matrix.buffer;
    4950  U = (float *) Mu[0].matrix.buffer;
    50   W = (float *) Vw[0].elements;
    5151  V = (float *) Mv[0].matrix.buffer;
     52  W = Vw[0].elements.Flt;
    5253
    5354  /* copy A to U (svdcmp replaces A with U) */

  • branches/eam_branch_20081124/Ohana/src/opihi/cmd.data/test/histogram.sh

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

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

    r7917 r20839  
    66  int Nx, Ny, NX, NY;
    77  int Xmin, Xmax, Ymin, Ymax;
    8   float *v, *x, *y, *z;
    98  Buffer *bf;
     9  float *v;
    1010  Vector *vx, *vy, *vz;
     11  opihi_flt *x, *y, *z;
    1112
    1213  if (argc != 9) {
    … …  
    2930  if ((vy = SelectVector (argv[7], ANYVECTOR, TRUE)) == NULL) return (FALSE);
    3031  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);
     32  REALLOCATE (vx[0].elements.Flt, opihi_flt, Nx*Ny);
     33  REALLOCATE (vy[0].elements.Flt, opihi_flt, Nx*Ny);
     34  REALLOCATE (vz[0].elements.Flt, opihi_flt, Nx*Ny);
    3435
    35   x = vx[0].elements;
    36   y = vy[0].elements;
    37   z = vz[0].elements;
     36  x = vx[0].elements.Flt;
     37  y = vy[0].elements.Flt;
     38  z = vz[0].elements.Flt;
    3839  n = 0;
    3940  v = (float *)bf[0].matrix.buffer;
    4041  for (j = Ymin; j < Ymax; j++) {
    4142    for (i = Xmin; i < Xmax; i++, x++, y++, z++, n++) {
    42       vx[0].elements[n] = i;
    43       vy[0].elements[n] = j;
     43      vx[0].elements.Flt[n] = i;
     44      vy[0].elements.Flt[n] = j;
    4445      if (i < 0) continue;
    4546      if (i >= NX) continue;
    4647      if (j < 0) continue;
    4748      if (j >= NY) continue;
    48       vz[0].elements[n] = v[i+j*NX];
     49      vz[0].elements.Flt[n] = v[i+j*NX];
    4950    }
    5051  }

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

    r7917 r20839  
    44 
    55  int Nnew, i, j, found;
    6   float *v1, *v2;
     6  opihi_flt *v1, *v2;
    77  Vector *ivec, *ovec;
    88
    … …  
    1616
    1717  /* allocate the maximum possible needed */
    18   ALLOCATE (ovec[0].elements, float, ivec[0].Nelements);
     18  ALLOCATE (ovec[0].elements.Flt, opihi_flt, ivec[0].Nelements);
    1919
    2020  Nnew = 0;
    21   v1 = ivec[0].elements;
     21  v1 = ivec[0].elements.Flt;
    2222  for (i = 0; i < ivec[0].Nelements; i++, v1++) {
    23     v2 = ovec[0].elements;
     23    v2 = ovec[0].elements.Flt;
    2424    found = FALSE;
    2525    for (j = 0; !found && (j < Nnew); j++, v2++) {
    … …  
    2727    }
    2828    if (!found) {
    29       ovec[0].elements[Nnew] = *v1;
     29      ovec[0].elements.Flt[Nnew] = *v1;
    3030      Nnew ++;
    3131    }
    … …  
    3333
    3434  ovec[0].Nelements = Nnew;
    35   REALLOCATE (ovec[0].elements, float, ovec[0].Nelements);
     35  REALLOCATE (ovec[0].elements.Flt, opihi_flt, ovec[0].Nelements);
    3636
    3737  return (TRUE);

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

    r7917 r20839  
    55  int i, j, n, N, Nin, Nout;
    66  int Normalize, Ignore;
    7   float *Vout, *Vin, IgnoreValue;
     7  opihi_flt *Vout, *Vin, IgnoreValue;
    88  double scale;
    99  Vector *in, *out;
    … …  
    4242  Nout = Nin / scale;
    4343
    44   REALLOCATE (out[0].elements, float, Nout);
     44  REALLOCATE (out[0].elements.Flt, opihi_flt, Nout);
    4545  out[0].Nelements = Nout;
    4646
    47   Vin  = in[0].elements;
    48   Vout = out[0].elements;
     47  Vin  = in[0].elements.Flt;
     48  Vout = out[0].elements.Flt;
    4949  for (n = j = 0; j < Nout; j++, Vout++) {
    5050    *Vout = 0;
    … …  
    5757    if (Normalize) {
    5858      if (N > 0) {
    59         *Vout /= (float) N;
     59        *Vout /= (opihi_flt) N;
    6060      } else {
    6161        *Vout = 0;

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

    r7917 r20839  
    55  int i, Npix, DO_NAN, DO_INF, N;
    66  double min, Vmin, max, Vmax, nan_val, inf_val;
    7   float *in;
     7  opihi_flt *in;
    88  Vector *vec;
    99
    … …  
    4141
    4242  Npix = vec[0].Nelements;
    43   in =   vec[0].elements;
     43  in =   vec[0].elements.Flt;
    4444
    4545  if (argc == 6) {
    … …  
    5151    }
    5252  }
    53   in = vec[0].elements;
     53  in = vec[0].elements.Flt;
    5454  if (DO_NAN) {
    5555    for (i = 0; i < Npix; i++, in++) {
    … …  
    5959    }
    6060  }
    61   in = vec[0].elements;
     61  in = vec[0].elements.Flt;
    6262  if (DO_INF) {
    6363    for (i = 0; i < Npix; i++, in++) {

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

    r16446 r20839  
    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];
    … …  
    4343
    4444  Npts = xvec[0].Nelements;
    45   ALLOCATE (dy, float, Npts);
    46   REALLOCATE (ovec[0].elements, float, Npts);
     45  ALLOCATE (dy, opihi_flt, Npts);
     46  REALLOCATE (ovec[0].elements.Flt, opihi_flt, Npts);
    4747
    4848  GET_VAR (par[0], "C0");
    … …  
    5252  Npar = 4;
    5353
    54   v1 = svec[0].elements;
     54  v1 = svec[0].elements.Flt;
    5555  v2 = dy;
    5656  for (i = 0; i < Npts; i++, v1++, v2++) {
    … …  
    5858  }
    5959 
    60   ochisq = mrqinit (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fgaussOD, !Quiet);
     60  ochisq = mrqinit (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fgaussOD, !Quiet);
    6161  dchisq = ochisq + 2*Npts;
    6262
    6363  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);
     64    chisq = mrqmin (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fgaussOD, !Quiet);
    6565    dchisq = ochisq - chisq;
    6666    ochisq = chisq;
    … …  
    7070
    7171  for (i = 0; i < Npts; i++) {
    72     ovec[0].elements[i] = fgaussOD (xvec[0].elements[i], par, Npar, dy);
     72    ovec[0].elements.Flt[i] = fgaussOD (xvec[0].elements.Flt[i], par, Npar, dy);
    7373  }
    7474  ovec[0].Nelements = Npts;
    … …  
    9090
    9191/* pars: x_o, sigma, I, back */
    92 float fgaussOD (float x, float *par, int Npar, float *dpar) {
     92opihi_flt fgaussOD (opihi_flt x, opihi_flt *par, int Npar, opihi_flt *dpar) {
    9393
    94   float z, r, f;
     94  opihi_flt z, r, f;
    9595
    9696  z = (x - par[0])/par[1];

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

    r9275 r20839  
    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;
    … …  
    3940  strcpy (bf[0].file, "(empty)");
    4041
    41   ALLOCATE (val, float, Nx*Ny);
    42   bzero (val, Nx*Ny*sizeof(float));
     42  ALLOCATE (val, opihi_flt, Nx*Ny);
     43  bzero (val, Nx*Ny*sizeof(opihi_flt));
    4344  ALLOCATE (Nval, int, Nx*Ny);
    4445  bzero (Nval, Nx*Ny*sizeof(int));
    4546
    46   x = vx[0].elements;
    47   y = vy[0].elements;
    48   z = vz[0].elements;
     47  x = vx[0].elements.Flt;
     48  y = vy[0].elements.Flt;
     49  z = vz[0].elements.Flt;
    4950  for (i = 0; i < vx[0].Nelements; i++, x++, y++, z++) {
    5051    Xb = (*x - Xmin) / dX;

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

    r19840 r20839  
    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].elements.Flt[i]+0.5;
     85    overlay[i].y = vecy[0].elements.Flt[i]+0.5;
    8686    overlay[i].dx = dx;
    8787    overlay[i].dy = dy;

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

    r16446 r20839  
    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];
    … …  
    4343
    4444  Npts = xvec[0].Nelements;
    45   ALLOCATE (dy, float, Npts);
    46   REALLOCATE (ovec[0].elements, float, Npts);
     45  ALLOCATE (dy, opihi_flt, Npts);
     46  REALLOCATE (ovec[0].elements.Flt, opihi_flt, Npts);
    4747
    4848  GET_VAR (par[0], "C0");
    … …  
    5454  /* careful of variable renomalization */
    5555
    56   v1 = svec[0].elements;
     56  v1 = svec[0].elements.Flt;
    5757  v2 = dy;
    5858  for (i = 0; i < Npts; i++, v1++, v2++) *v2 = 1.0 / (*v1 * *v1);
    5959 
    60   ochisq = mrqinit (xvec[0].elements, yvec[0].elements, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
     60  ochisq = mrqinit (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
    6161  dchisq = ochisq + 2*Npts;
    6262
    6363  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);
     64    chisq = mrqmin (xvec[0].elements.Flt, yvec[0].elements.Flt, dy, Npts, par, Npar, fmaxwellOD, !Quiet);
    6565    dchisq = ochisq - chisq;
    6666    ochisq = chisq;
    … …  
    7070
    7171  for (i = 0; i < Npts; i++) {
    72     ovec[0].elements[i] = fmaxwellOD (xvec[0].elements[i], par, Npar, dy);
     72    ovec[0].elements.Flt[i] = fmaxwellOD (xvec[0].elements.Flt[i], par, Npar, dy);
    7373  }
    7474  ovec[0].Nelements = Npts;
    … …  
    9090
    9191/* pars: x_o, -0.5/sigma^2, I, back, ref */
    92 float fmaxwellOD (float x, float *par, int Npar, float *dpar) {
     92opihi_flt fmaxwellOD (opihi_flt x, opihi_flt *par, int Npar, opihi_flt *dpar) {
    9393
    94   float z, r, f;
     94  opihi_flt z, r, f;
    9595
    9696  z = (x - par[0])/par[1];

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

    r7917 r20839  
    1717
    1818  if (Npix > 1) {
    19     memmove (&vec[0].elements[0], &vec[0].elements[1], Npix*sizeof(float));
     19    memmove (&vec[0].elements.Flt[0], &vec[0].elements.Flt[1], Npix*sizeof(opihi_flt));
    2020  }
    2121  vec[0].Nelements = Npix - 1;

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

    r7917 r20839  
    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  first = vec[0].elements.Flt[0];
     20  memmove (&vec[0].elements.Flt[0], &vec[0].elements.Flt[1], Npix*sizeof(opihi_flt));
     21  vec[0].elements.Flt[Npix-1] = first;
    2222  return (TRUE);
    2323}

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

    r7917 r20839  
    44 
    55  int i, n, N, Nx, Ns, Ngauss;
    6   float *vi, *vo, *gauss, *gaussnorm;
     6  opihi_flt *vi, *vo, *gauss, *gaussnorm;
    77  float g, s, sigma, Nsigma;
    88  Vector *in;
    … …  
    2323  sigma = atof (argv[2]);
    2424  Nx = in[0].Nelements;
    25   vi = in[0].elements;
     25  vi = in[0].elements.Flt;
    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);
    3737
    3838  for (i = 0; i < Nx; i++) {
    … …  
    4747  }
    4848
    49   free (in[0].elements);
     49  free (in[0].elements.Flt);
    5050  free (gaussnorm);
    5151
    52   in[0].elements = vo;
     52  in[0].elements.Flt = vo;
    5353  return (TRUE);
    5454}

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

    r7917 r20839  
    55  int i, N;
    66  double max, min, sum, var, dvar, mean, stdev;
    7   float *X, IgnoreValue;
     7  opihi_flt *X, IgnoreValue;
    88  int Ignore, Quiet;
    99
    … …  
    4141
    4242  /* calculate max, min, mean, sum, npix */
    43   X = vec[0].elements;
     43  X = vec[0].elements.Flt;
    4444  max = -HUGE_VAL;
    4545  min = HUGE_VAL;
    … …  
    6565  ALLOCATE (Nval, int, 1002);
    6666  bzero (Nval, 1000*sizeof(int));
    67   X = vec[0].elements;
     67  X = vec[0].elements.Flt;
    6868  var = 0;
    6969  for (i = 0; i < vec[0].Nelements; i++, X++) {

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

    r17419 r20839  
    5858
    5959  for (i = N = 0; i < Noverlay; i++) {
    60     size = MIN (MAX_OUTPUT_SIZE, (vecz[0].elements[i] - min) / range);
     60    size = MIN (MAX_OUTPUT_SIZE, (vecz[0].elements.Flt[i] - min) / range);
    6161    if (size < 0.1) continue;
    6262
    6363    overlay[N].type = type;
    6464    overlay[N].text = NULL;
    65     overlay[N].x = vecx[0].elements[i]+0.5;
    66     overlay[N].y = vecy[0].elements[i]+0.5;
     65    overlay[N].x = vecx[0].elements.Flt[i]+0.5;
     66    overlay[N].y = vecy[0].elements.Flt[i]+0.5;
    6767    overlay[N].angle = 0.0;
    6868

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

    r20820 r20839  
    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        fprintf (f, "%.10g ", vec[j][0].elements.Flt[i]);
    8181      }
    8282      fprintf (f, "\n");
    … …  
    135135    for (j = 0; j < Nvec; j++) {
    136136      if (fmttype[j] == 'd') {
    137         fprintf (f, fmtlist[j], (int)(vec[j][0].elements[i]));
     137        fprintf (f, fmtlist[j], (int)(vec[j][0].elements.Flt[i]));
    138138      }
    139139      if (fmttype[j] == 'f') {
    140         fprintf (f, fmtlist[j], (float)(vec[j][0].elements[i]));
     140        fprintf (f, fmtlist[j], (float)(vec[j][0].elements.Flt[i]));
    141141      }
    142142    }

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

    r14590 r20839  
    44 
    55  int i, kapa, Npts;
    6   float *in, *out;
     6  opihi_flt *in, *out;
    77  double min, range;
    88  Graphdata graphmode;
    … …  
    3232  }
    3333  Zvec.Nelements = zvec[0].Nelements;
    34   ALLOCATE (Zvec.elements, float, Zvec.Nelements);
     34  ALLOCATE (Zvec.elements.Flt, opihi_flt, Zvec.Nelements);
    3535 
    36   in = zvec[0].elements;
    37   out = Zvec.elements;
     36  in = zvec[0].elements.Flt;
     37  out = Zvec.elements.Flt;
    3838  for (i = 0; i < Zvec.Nelements; i++, in++, out++) {
    3939    *out = MIN (1.0, MAX (0.01, (*in - min) / range));
    … …  
    4545  graphmode.etype = 0; /* no errorbars */
    4646  Npts = xvec[0].Nelements;
    47   PlotVectorTriplet (kapa, Npts, xvec[0].elements, yvec[0].elements, Zvec.elements, &graphmode);
     47  PlotVectorTriplet (kapa, Npts, xvec[0].elements.Flt, yvec[0].elements.Flt, Zvec.elements.Flt, &graphmode);
    4848
    49   free (Zvec.elements);
     49  free (Zvec.elements.Flt);
    5050
    5151  return (TRUE);

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

    r20820 r20839  
    11# include "dvoshell.h"
    22
     3// XXX need to promote values (and dbStack entries) to opihi_flt, but wait until done testing
    34int avextract (int argc, char **argv) {
    45 
    … …  
    116117      if (!dbBooleanCond (stack, Nstack, values)) continue;
    117118      for (n = 0; n < Nreturn; n++) {
    118         vec[n][0].elements[Npts] = values[n];
     119        vec[n][0].elements.Flt[Npts] = values[n];
    119120      }
    120121      Npts++;
    … …  
    122123        NPTS += 2000;
    123124        for (n = 0; n < Nreturn; n++) {
    124           REALLOCATE (vec[n][0].elements, float, NPTS);
     125          REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
    125126        }
    126127      }
    … …  
    132133  for (n = 0; n < Nreturn; n++) {
    133134    vec[n][0].Nelements = Npts;
    134     REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
     135    REALLOCATE (vec[n][0].elements.Flt, opihi_flt, MAX(1,Npts));
    135136  }
    136137

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

    r15509 r20839  
    6161  if ((vec[Nd2] = SelectVector ("cal:dm2",      ANYVECTOR, TRUE)) == NULL) goto escape;
    6262  for (k = 0; k < NVEC; k++) {
    63     REALLOCATE (vec[k][0].elements, float, NSTAR);
     63    REALLOCATE (vec[k][0].elements.Flt, opihi_flt, NSTAR);
    6464    vec[k][0].Nelements = 0;
    6565  }
    … …  
    110110        NSTAR += N1 + 100;
    111111        for (k = 0; k < NVEC; k++) {
    112           REALLOCATE (vec[k][0].elements, float, NSTAR);
     112          REALLOCATE (vec[k][0].elements.Flt, opihi_flt, NSTAR);
    113113        }
    114114      }
    … …  
    125125
    126126      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;
     127        vec[Nd ][0].elements.Flt[N] = M1[j] - M2;
     128        vec[Nm1][0].elements.Flt[N] = M1[j];
     129        vec[Nm2][0].elements.Flt[N] = M2;
     130        vec[Nd2][0].elements.Flt[N] = dM2;
     131        vec[Nc ][0].elements.Flt[N] = color;
     132        vec[Ns ][0].elements.Flt[N] = Nstar;
     133        vec[NR ][0].elements.Flt[N] = catalog.average[i].R;
     134        vec[ND ][0].elements.Flt[N] = catalog.average[i].D;
    135135      }
    136136      Nstar ++;
    … …  
    178178  Ns = vec[0].Nelements;
    179179  for (i = 0; i < N; i++) {
    180     vec[0].elements[Ns+i] = value[i];
     180    vec[0].elements.Flt[Ns+i] = value[i];
    181181  }
    182182  vec[0].Nelements = Ns + N;

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

    r20820 r20839  
    9797      for (i1 = 0; i1 < N1; i1++) {
    9898        for (i2 = 0; i2 < N2; i2++) {
    99           xvec[0].elements[Npts] = M1[i1];
    100           yvec[0].elements[Npts] = M2[i2];
     99          xvec[0].elements.Flt[Npts] = M1[i1];
     100          yvec[0].elements.Flt[Npts] = M2[i2];
    101101          Npts++;
    102102          if (Npts >= NPTS) {
    103103            NPTS += 2000;
    104             REALLOCATE (xvec[0].elements, float, NPTS);
    105             REALLOCATE (yvec[0].elements, float, NPTS);
     104            REALLOCATE (xvec[0].elements.Flt, opihi_flt, NPTS);
     105            REALLOCATE (yvec[0].elements.Flt, opihi_flt, NPTS);
    106106          }
    107107        }

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

    r20820 r20839  
    9595      for (i1 = 0; i1 < N1; i1++) {
    9696        for (i3 = 0; i3 < N3; i3++) {
    97           xvec[0].elements[Npts] = M1[i1];
    98           yvec[0].elements[Npts] = M3[i3];
     97          xvec[0].elements.Flt[Npts] = M1[i1];
     98          yvec[0].elements.Flt[Npts] = M3[i3];
    9999          Npts++;
    100100          if (Npts >= NPTS) {
    101101            NPTS += 2000;
    102             REALLOCATE (xvec[0].elements, float, NPTS);
    103             REALLOCATE (yvec[0].elements, float, NPTS);
     102            REALLOCATE (xvec[0].elements.Flt, opihi_flt, NPTS);
     103            REALLOCATE (yvec[0].elements.Flt, opihi_flt, NPTS);
    104104          }
    105105        }

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

    r15487 r20839  
    8989  fclose (f);
    9090
    91   REALLOCATE (vec[0].elements, float, Nstars);
     91  REALLOCATE (vec[0].elements.Flt, opihi_flt, Nstars);
    9292  vec[0].Nelements = Nstars;
    93   bzero (vec[0].elements, Nstars*sizeof(float));
     93  bzero (vec[0].elements.Flt, Nstars*sizeof(opihi_flt));
    9494
    9595  value = 0;
    … …  
    135135        break;
    136136    }
    137     vec[0].elements[i] = value;
     137    vec[0].elements.Flt[i] = value;
    138138  }     
    139139  free (stars);

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

    r12332 r20839  
    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  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);
    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);
     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);
    6767 
    6868  rvec[0].Nelements = Nmatch;

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

    r14590 r20839  
    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  REALLOCATE (vec[0].elements.Flt, 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

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

    r16810 r20839  
    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  opihi_flt *colorFit, *deltaFit, dColor, C0, C1;
     21  opihi_flt minDelta, maxDelta, minColor, maxColor;
    2122  int kapa, Npx, Npy, NPX, NPY, Nplot, PLOT;
    2223  Graphdata graphdata;
    … …  
    99100    KapaSetFont (kapa, "helvetica", 14);
    100101
    101     ALLOCATE (colorFit, float, 11);
    102     ALLOCATE (deltaFit, float, 11);
     102    ALLOCATE (colorFit, opihi_flt, 11);
     103    ALLOCATE (deltaFit, opihi_flt, 11);
    103104    dColor = (maxColor - minColor) / 10.0;
    104105    for (i = 0; i < 11; i++) {
    … …  
    232233              if (M2[i2] < minColor) continue;
    233234              if (M2[i2] > maxColor) continue;
    234               yvec[0].elements[Npts] = M1[i1];
    235               xvec[0].elements[Npts] = M2[i2];
     235              yvec[0].elements.Flt[Npts] = M1[i1];
     236              xvec[0].elements.Flt[Npts] = M2[i2];
    236237              Npts++;
    237238              if (Npts >= NPTS) {
    238239                NPTS += 2000;
    239                 REALLOCATE (xvec[0].elements, float, NPTS);
    240                 REALLOCATE (yvec[0].elements, float, NPTS);
     240                REALLOCATE (xvec[0].elements.Flt, opihi_flt, NPTS);
     241                REALLOCATE (yvec[0].elements.Flt, opihi_flt, NPTS);
    241242              }
    242243            }
    … …  
    305306        KapaSetLimits (kapa, &graphdata);
    306307        KapaBox (kapa, &graphdata);
    307         KapaPrepPlot (kapa, Npts, &graphdata);
    308         KapaPlotVector (kapa, Npts, xvec[0].elements, "x");
    309         KapaPlotVector (kapa, Npts, yvec[0].elements, "y");
     308
     309        PlotVectorPair (kapa, Npts, xvec[0].elements.Flt, yvec[0].elements.Flt, &graphdata);
    310310
    311311        for (i = 0; i < 11; i++) {
    … …  
    314314        graphdata.style = 0;
    315315        graphdata.color = KapaColorByName ("red");
    316         KapaPrepPlot (kapa, 11, &graphdata);
    317         KapaPlotVector (kapa, 11, colorFit, "x");
    318         KapaPlotVector (kapa, 11, deltaFit, "y");
     316
     317        PlotVectorPair (kapa, 11, colorFit, deltaFit, &graphdata);
    319318
    320319        KapaSetFont (kapa, "helvetica", 8);

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

    r19823 r20839  
    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    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);
    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          }

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

    r19823 r20839  
    113113
    114114  npts = NPTS = 200;
    115   ALLOCATE (Xvec.elements, float, NPTS);
    116   ALLOCATE (Yvec.elements, float, NPTS);
     115  ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     116  ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    117117  ALLOCATE (plist, int, NPTS);
    118118  n = N = 0;
    … …  
    238238    status = FALSE;
    239239    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);
     240      status |= RD_to_XY (&Xvec.elements.Flt[N+2*j], &Yvec.elements.Flt[N+2*j], r[j], d[j], &graphmode.coords);
    241241      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];
     242        Xvec.elements.Flt[N+2*j - 1] = Xvec.elements.Flt[N+2*j];
     243        Yvec.elements.Flt[N+2*j - 1] = Yvec.elements.Flt[N+2*j];
    244244      }
    245245    }
    246     Xvec.elements[N+2*Npts-1] = Xvec.elements[N];
    247     Yvec.elements[N+2*Npts-1] = Yvec.elements[N];
     246    Xvec.elements.Flt[N+2*Npts-1] = Xvec.elements.Flt[N];
     247    Yvec.elements.Flt[N+2*Npts-1] = Yvec.elements.Flt[N];
    248248    if (!status) continue;
    249249    // if none of the points are on the visible side of the projection, do not plot the image
    … …  
    251251    InPic = FALSE;
    252252    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))
     253      if ((Xvec.elements.Flt[N+j] >= graphmode.xmin) &&
     254          (Xvec.elements.Flt[N+j] <= graphmode.xmax) &&
     255          (Yvec.elements.Flt[N+j] >= graphmode.ymin) &&
     256          (Yvec.elements.Flt[N+j] <= graphmode.ymax))
    257257        InPic = TRUE;
    258258    }
    … …  
    269269    if (N + 16 >= NPTS) {  /* need to leave room for 8 point image */
    270270      NPTS += 400;
    271       REALLOCATE (Xvec.elements, float, NPTS);
    272       REALLOCATE (Yvec.elements, float, NPTS);
     271      REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     272      REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    273273    }
    274274  }
    … …  
    280280    graphmode.ptype = 100; /* connect pairs of points */
    281281    graphmode.etype = 0;
    282     PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
    283   }
    284 
    285   free (Xvec.elements);
    286   free (Yvec.elements);
     282    PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
     283  }
     284
     285  free (Xvec.elements.Flt);
     286  free (Yvec.elements.Flt);
    287287  free (image);
    288288  return (TRUE);

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

    r20212 r20839  
    3636 
    3737  /* project this image to screen display coords */
    38   ALLOCATE (Xvec.elements, float, 8);
    39   ALLOCATE (Yvec.elements, float, 8);
     38  ALLOCATE (Xvec.elements.Flt, opihi_flt, 8);
     39  ALLOCATE (Yvec.elements.Flt, 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    }
    … …  
    104104      graphmode.ptype = 100; /* connect pairs of points */
    105105      graphmode.etype = 0;
    106       PlotVectorPair (kapa, 8, Xvec.elements, Yvec.elements, &graphmode);
     106      PlotVectorPair (kapa, 8, Xvec.elements.Flt, Yvec.elements.Flt, &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

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

    r20820 r20839  
    125125  /* create output vector */
    126126  NPTS = 1000;
    127   REALLOCATE (vec[0].elements, float, NPTS);
     127  REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS);
    128128  vec[0].Nelements = N = 0;
    129129
    … …  
    153153          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    154154          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);
     155          vec[0].elements.Flt[N] = catalog.average[n].R - catalog.measure[i].dR / 3600.0;
     156          N++;
     157          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    158158        }
    159159        break;
    … …  
    162162          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    163163          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);
     164          vec[0].elements.Flt[N] = catalog.average[n].D - catalog.measure[i].dD / 3600.0;
     165          N++;
     166          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    167167        }
    168168        break;
    … …  
    170170        for (i = 0; i < catalog.Nmeasure; i++) {
    171171          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);
     172          vec[0].elements.Flt[N] = catalog.measure[i].M;
     173          N++;
     174          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    175175        }
    176176        break;
    … …  
    178178        for (i = 0; i < catalog.Nmeasure; i++) {
    179179          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);
     180          vec[0].elements.Flt[N] = catalog.measure[i].dM;
     181          N++;
     182          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    183183        }
    184184        break;
    … …  
    186186        for (i = 0; i < catalog.Nmeasure; i++) {
    187187          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);
     188          vec[0].elements.Flt[N] = catalog.measure[i].Mcal;
     189          N++;
     190          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    191191        }
    192192        break;
    … …  
    195195          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    196196          n = catalog.measure[i].averef;
    197           // vec[0].elements[N] = catalog.average[n].M;
     197          // vec[0].elements.Flt[N] = catalog.average[n].M;
    198198          N++;
    199199        }
    … …  
    202202        for (i = 0; i < catalog.Nmeasure; i++) {
    203203          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);
     204          vec[0].elements.Flt[N] = catalog.measure[i].photcode;
     205          N++;
     206          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    207207        }
    208208        break;
    … …  
    210210        for (i = 0; i < catalog.Nmeasure; i++) {
    211211          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);
     212          vec[0].elements.Flt[N] = TimeValue (catalog.measure[i].t, TimeReference, TimeFormat);
     213          N++;
     214          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    215215        }
    216216        break;
    … …  
    220220 
    221221  vec[0].Nelements = N;
    222   REALLOCATE (vec[0].elements, float, MAX(1,N));
     222  REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX(1,N));
    223223  return (TRUE);
    224224}

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

    r19823 r20839  
    3131
    3232  NPTS = 200;
    33   ALLOCATE (Xvec.elements, float, NPTS);
    34   ALLOCATE (Yvec.elements, float, NPTS);
     33  ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     34  ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    3535  N = 0;
    3636  for (i = 0; i < Nimage; i++) {
    … …  
    4545    while (r < Rmin) r += 360.0;
    4646    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) {
     47    status |= RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], r, d, &graphmode.coords);
     48    if ((Xvec.elements.Flt[N] >= graphmode.xmin) &&
     49        (Xvec.elements.Flt[N] <= graphmode.xmax) &&
     50        (Yvec.elements.Flt[N] >= graphmode.ymin) &&
     51        (Yvec.elements.Flt[N] <= graphmode.ymax) && status) {
    5252      N++;
    5353      if (N > NPTS - 1) {
    5454        NPTS += 200;
    55         REALLOCATE (Xvec.elements, float, NPTS);
    56         REALLOCATE (Yvec.elements, float, NPTS);
     55        REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     56        REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    5757      }
    5858    }
    … …  
    6363    graphmode.style = 2; /* points */
    6464    graphmode.etype = 0;
    65     PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     65    PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    6666  }
    6767
    68   free (Xvec.elements);
    69   free (Yvec.elements);
     68  free (Xvec.elements.Flt);
     69  free (Yvec.elements.Flt);
    7070  free (image);
    7171  return (TRUE);

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

    r17246 r20839  
    165165
    166166  /* create storage vector */
    167   REALLOCATE (vec[0].elements, float, Nimage);
     167  REALLOCATE (vec[0].elements.Flt, opihi_flt, Nimage);
    168168  vec[0].Nelements = Nimage;
    169169 
    … …  
    186186        y = 0.5*image[j].NY;
    187187        XY_to_RD (&ra, &dec, x, y, &image[j].coords);
    188         vec[0].elements[N] = ra;
     188        vec[0].elements.Flt[N] = ra;
    189189        break;
    190190      case DEC:
    … …  
    193193        y = 0.5*image[j].NY;
    194194        XY_to_RD (&ra, &dec, x, y, &image[j].coords);
    195         vec[0].elements[N] = dec;
     195        vec[0].elements.Flt[N] = dec;
    196196        break;
    197197      case Xm:
    198         vec[0].elements[N] = pow(10.0, 0.01*image[j].Xm);
     198        vec[0].elements.Flt[N] = pow(10.0, 0.01*image[j].Xm);
    199199        break;
    200200      case AIRMASS:
    201         vec[0].elements[N] = image[j].secz;
     201        vec[0].elements.Flt[N] = image[j].secz;
    202202        break;
    203203      case MCAL:
    204         vec[0].elements[N] = image[j].Mcal;
     204        vec[0].elements.Flt[N] = image[j].Mcal;
    205205        break;
    206206      case dMCAL:
    207         vec[0].elements[N] = image[j].dMcal;
     207        vec[0].elements.Flt[N] = image[j].dMcal;
    208208        break;
    209209      case PHOTCODE:
    210         vec[0].elements[N] = image[j].photcode;
     210        vec[0].elements.Flt[N] = image[j].photcode;
    211211        break;
    212212      case TIME:
    213213        t = image[j].tzero + 0.5*image[j].NY * image[j].trate / 10000;
    214         vec[0].elements[N] = TimeValue (t, TimeReference, TimeFormat);
     214        vec[0].elements.Flt[N] = TimeValue (t, TimeReference, TimeFormat);
    215215        break;
    216216      case FWHM:
    217         vec[0].elements[N] = image[j].fwhm_x / 25.0;
     217        vec[0].elements.Flt[N] = image[j].fwhm_x / 25.0;
    218218        break;
    219219      case EXPTIME:
    220         vec[0].elements[N] = image[j].exptime;
     220        vec[0].elements.Flt[N] = image[j].exptime;
    221221        break;
    222222      case NSTAR:
    223         vec[0].elements[N] = image[j].nstar;
     223        vec[0].elements.Flt[N] = image[j].nstar;
    224224        break;
    225225      case NCAL:
    226         vec[0].elements[N] = image[j].Mxxxx;
     226        vec[0].elements.Flt[N] = image[j].Mxxxx;
    227227        break;
    228228      case SKY:
    229         vec[0].elements[N] = image[j].Myyyy + 0x8000;
     229        vec[0].elements.Flt[N] = image[j].Myyyy + 0x8000;
    230230        break;
    231231      case FLAG:
    232         vec[0].elements[N] = image[j].code;
     232        vec[0].elements.Flt[N] = image[j].code;
    233233        break;
    234234      case NX_PIX:
    235         vec[0].elements[N] = image[j].NX;
     235        vec[0].elements.Flt[N] = image[j].NX;
    236236        break;
    237237      case NY_PIX:
    238         vec[0].elements[N] = image[j].NY;
     238        vec[0].elements.Flt[N] = image[j].NY;
    239239        break;
    240240      case IMAGE_ID:
    241         vec[0].elements[N] = image[j].imageID;
     241        vec[0].elements.Flt[N] = image[j].imageID;
    242242        break;
    243243      case THETA: {
    … …  
    247247        theta1 = DEG_RAD*atan2 (+s1*image[j].coords.pc1_2, s1*image[j].coords.pc1_1);
    248248        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);
     249        vec[0].elements.Flt[N] = 0.5*(theta1+theta2);
    250250        break; }
    251251      case SKEW: {
    … …  
    255255        theta1 = DEG_RAD*atan2 (+s1*image[j].coords.pc1_2, s1*image[j].coords.pc1_1);
    256256        theta2 = DEG_RAD*atan2 (-s2*image[j].coords.pc2_1, s2*image[j].coords.pc2_2);
    257         vec[0].elements[N] = (theta1-theta2);
     257        vec[0].elements.Flt[N] = (theta1-theta2);
    258258        break; }
    259259      case SCALE: {
    … …  
    261261        scale1 = fabs(image[j].coords.cdelt1);
    262262        scale2 = fabs(image[j].coords.cdelt2);
    263         vec[0].elements[N] = 0.5*(scale1+scale2);
     263        vec[0].elements.Flt[N] = 0.5*(scale1+scale2);
    264264        break; }
    265265      case DSCALE: {
    … …  
    267267        scale1 = fabs(image[j].coords.cdelt1);
    268268        scale2 = fabs(image[j].coords.cdelt2);
    269         vec[0].elements[N] = (scale1-scale2);
     269        vec[0].elements.Flt[N] = (scale1-scale2);
    270270        break; }
    271271
    … …  
    275275    case Y_LR_CHIP:
    276276    case X_UL_CHIP:
    277       vec[0].elements[N] = 0.0;
     277      vec[0].elements.Flt[N] = 0.0;
    278278      break;
    279279    case X_LR_CHIP:
    280280    case X_UR_CHIP:
    281       vec[0].elements[N] = image[j].NX;
     281      vec[0].elements.Flt[N] = image[j].NX;
    282282      break;
    283283    case Y_UL_CHIP:
    284284    case Y_UR_CHIP:
    285       vec[0].elements[N] = image[j].NX;
     285      vec[0].elements.Flt[N] = image[j].NX;
    286286      break;
    287287
    … …  
    289289    case Y_LL_FP:
    290290      XY_to_LM (&x, &y, 0.0, 0.0, &image[j].coords);
    291       vec[0].elements[N] = (mode == X_LL_FP) ? x : y;
     291      vec[0].elements.Flt[N] = (mode == X_LL_FP) ? x : y;
    292292      break;
    293293    case X_LR_FP:
    294294    case Y_LR_FP:
    295295      XY_to_LM (&x, &y, image[j].NX, 0.0, &image[j].coords);
    296       vec[0].elements[N] = (mode == X_LR_FP) ? x : y;
     296      vec[0].elements.Flt[N] = (mode == X_LR_FP) ? x : y;
    297297      break;
    298298    case X_UL_FP:
    299299    case Y_UL_FP:
    300300      XY_to_LM (&x, &y, 0.0, image[j].NY, &image[j].coords);
    301       vec[0].elements[N] = (mode == X_UL_FP) ? x : y;
     301      vec[0].elements.Flt[N] = (mode == X_UL_FP) ? x : y;
    302302      break;
    303303    case X_UR_FP:
    304304    case Y_UR_FP:
    305305      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;
     306      vec[0].elements.Flt[N] = (mode == X_UR_FP) ? x : y;
    307307      break;
    308308    }
    … …  
    311311 
    312312  vec[0].Nelements = N;
    313   REALLOCATE (vec[0].elements, float, N);
     313  REALLOCATE (vec[0].elements.Flt, opihi_flt, N);
    314314
    315315  free (subset);

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

    r14590 r20839  
    1313  char DataBase[256], *Filter;
    1414  double trange;
    15   float *Vec;
     15  opihi_flt *Vec;
    1616  time_t tzero, tend, TimeReference;
    1717  RegImage *image;
    … …  
    132132  N = 0;
    133133  NVEC = 1000;
    134   REALLOCATE (vec[0].elements, float, NVEC);
    135   Vec = vec[0].elements;
     134  REALLOCATE (vec[0].elements.Flt, opihi_flt, NVEC);
     135  Vec = vec[0].elements.Flt;
    136136
    137137  GetTimeFormat (&TimeReference, &TimeFormat);
    … …  
    216216    if (N >= NVEC - 1) {
    217217      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));
     218      REALLOCATE (vec[0].elements.Flt, opihi_flt, NVEC);
     219      Vec = vec[0].elements.Flt;
     220    }
     221  }
     222
     223  REALLOCATE (vec[0].elements.Flt, opihi_flt, MAX (1,N));
    224224  vec[0].Nelements = N;
    225225

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

    r13479 r20839  
    3535  Xvec.Nelements = Nimage;
    3636  Yvec.Nelements = Nimage;
    37   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    38   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
     37  ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     38  ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    3939  gprint (GP_LOG, "seq  ra (J2000) dec    time (s)   Nstars\n");
    4040  for (i = 0; i < Nimage; i++) {
    41     Xvec.elements[i] = image[i].secz;
     41    Xvec.elements.Flt[i] = image[i].secz;
    4242    if (Mcal)
    43       Yvec.elements[i] = image[i].Mcal;
     43      Yvec.elements.Flt[i] = image[i].Mcal;
    4444    else
    45       Yvec.elements[i] = image[i].dMcal;
     45      Yvec.elements.Flt[i] = image[i].dMcal;
    4646    if (!FindMosaicForImage (image, Nimage, i)) continue;
    4747    XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    4848    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],
     49             i, r, d, image[i].tzero, image[i].nstar, Xvec.elements.Flt[i],
    5050             image[i].Mcal, image[i].dMcal);
    5151  }
    … …  
    5454  graphmode.style = 2;
    5555  graphmode.etype = 0;
    56   PlotVectorPair (kapa, Nimage, Xvec.elements, Yvec.elements, &graphmode);
     56  PlotVectorPair (kapa, Nimage, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    5757 
    58   free (Xvec.elements);
    59   free (Yvec.elements);
     58  free (Xvec.elements.Flt);
     59  free (Yvec.elements.Flt);
    6060  return (TRUE);
    6161}

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

    r16810 r20839  
    103103
    104104  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); }
     105  ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     106  ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
     107  dYvec.elements.Flt = NULL;
     108  if (ErrorBars) { ALLOCATE (dYvec.elements.Flt, opihi_flt, NPTS); }
    109109  N = 0;
    110110
    … …  
    124124      m = catalog.average[N1[i]].measureOffset;
    125125      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]);
     126        if (ErrorBars) dYvec.elements.Flt[N] = catalog.measure[m].dM;
     127        Xvec.elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
     128        Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m]);
    129129        /**** need to use PhotRel optionally here ****/
    130130        N++;
    131131        if (N == NPTS) {
    132132          NPTS += 100;
    133           REALLOCATE (Xvec.elements, float, NPTS);
    134           REALLOCATE (Yvec.elements, float, NPTS);
    135           if (ErrorBars) { REALLOCATE (dYvec.elements, float, NPTS); }
     133          REALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     134          REALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
     135          if (ErrorBars) { REALLOCATE (dYvec.elements.Flt, opihi_flt, NPTS); }
    136136        }
    137137      }     
    … …  
    142142 
    143143  if (ErrorBars)
    144     fsortthree (Xvec.elements, Yvec.elements, dYvec.elements, N);
     144    dsortthree (Xvec.elements.Flt, Yvec.elements.Flt, dYvec.elements.Flt, N);
    145145  else
    146     fsortpair (Xvec.elements, Yvec.elements, N);
     146    dsortpair (Xvec.elements.Flt, Yvec.elements.Flt, N);
    147147
    148148  /* autoscale the plot */
    … …  
    154154    graphmode.etype = 0; 
    155155
    156   KapaPrepPlot (kapa, N, &graphmode);
    157   KapaPlotVector (kapa, N, Xvec.elements, "x");
    158   KapaPlotVector (kapa, N, Yvec.elements, "y");
    159156  if (ErrorBars) {
    160     KapaPlotVector (kapa, N, dYvec.elements, "dym");
    161     KapaPlotVector (kapa, N, dYvec.elements, "dyp");
     157    PlotVectorPairErrors (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, dYvec.elements.Flt, &graphmode);
     158  } else {
     159    PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    162160  }
    163161
    … …  
    175173
    176174  if (SaveVectors) {
    177     free (xvec[0].elements);
    178     free (yvec[0].elements);
    179     xvec[0].elements = Xvec.elements;
    180     yvec[0].elements = Yvec.elements;
     175    free (xvec[0].elements.Flt);
     176    free (yvec[0].elements.Flt);
     177    xvec[0].elements.Flt = Xvec.elements.Flt;
     178    yvec[0].elements.Flt = Yvec.elements.Flt;
    181179    xvec[0].Nelements = yvec[0].Nelements = Xvec.Nelements;
    182180  } else {
    183     free (Xvec.elements);
    184     free (Yvec.elements);
     181    free (Xvec.elements.Flt);
     182    free (Yvec.elements.Flt);
    185183  }
    186184
    187   if (ErrorBars) free (dYvec.elements);
     185  if (ErrorBars) free (dYvec.elements.Flt);
    188186  dvo_catalog_free (&catalog);
    189187

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

    r16810 r20839  
    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  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);
    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

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

    r20820 r20839  
    139139        if (!dbBooleanCond (stack, Nstack, values)) continue;
    140140        for (n = 0; n < Nreturn; n++) {
    141           vec[n][0].elements[Npts] = values[n];
     141          vec[n][0].elements.Flt[Npts] = values[n];
    142142          // fprintf (stderr, "keep : field: %s, value: %f\n", fields[n].name, values[n]);
    143143        }
    … …  
    146146          NPTS += 2000;
    147147          for (n = 0; n < Nreturn; n++) {
    148             REALLOCATE (vec[n][0].elements, float, NPTS);
     148            REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
    149149          }
    150150        }
    … …  
    162162  for (n = 0; n < Nreturn; n++) {
    163163    vec[n][0].Nelements = Npts;
    164     REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
     164    REALLOCATE (vec[n][0].elements.Flt, opihi_flt, MAX(1,Npts));
    165165  }
    166166

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

    r20820 r20839  
    232232        for (n2 = 0; n2 < Nt2; n2++) {
    233233          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];
     234            vec[2*n+0][0].elements.Flt[Npts] = table1[n][n1];
     235            vec[2*n+1][0].elements.Flt[Npts] = table2[n][n2];
    236236          }
    237237          Npts++;
    … …  
    239239            NPTS += 2000;
    240240            for (n = 0; n < Nreturn; n++) {
    241               REALLOCATE (vec[n][0].elements, float, NPTS);
     241              REALLOCATE (vec[n][0].elements.Flt, opihi_flt, NPTS);
    242242            }
    243243          }
    … …  
    257257  for (n = 0; n < Nreturn; n++) {
    258258    vec[n][0].Nelements = Npts;
    259     REALLOCATE (vec[n][0].elements, float, MAX(1,Npts));
     259    REALLOCATE (vec[n][0].elements.Flt, opihi_flt, MAX(1,Npts));
    260260  }
    261261

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

    r20820 r20839  
    1010  double Radius, Rmin, Rmax, R, D;
    1111  unsigned IDclip, IDchoice, LimExclude;
    12   float *Xvec, *Yvec, *Zvec;
     12  opihi_flt *Xvec, *Yvec, *Zvec;
    1313  void *Signal;
    1414
    … …  
    9696  Npts = 0;
    9797  NPTS = 1000;
    98   ALLOCATE (Xvec, float, NPTS);
    99   ALLOCATE (Yvec, float, NPTS);
    100   ALLOCATE (Zvec, float, NPTS);
     98  ALLOCATE (Xvec, opihi_flt, NPTS);
     99  ALLOCATE (Yvec, opihi_flt, NPTS);
     100  ALLOCATE (Zvec, opihi_flt, NPTS);
    101101
    102102  // prepare to handle interrupt signals
    … …  
    133133      R = average[i].R;
    134134      D = average[i].D;
    135       status = fRD_to_XY (&Xvec[Npts], &Yvec[Npts], R, D, &graphmode.coords);
     135      status = RD_to_XY (&Xvec[Npts], &Yvec[Npts], R, D, &graphmode.coords);
    136136      if (!status) continue;
    137137      Npts ++;
    … …  
    139139      if (Npts == NPTS - 1) {
    140140          NPTS += 1000;
    141           REALLOCATE (Xvec, float, NPTS);
    142           REALLOCATE (Yvec, float, NPTS);
    143           REALLOCATE (Zvec, float, NPTS);
     141          REALLOCATE (Xvec, opihi_flt, NPTS);
     142          REALLOCATE (Yvec, opihi_flt, NPTS);
     143          REALLOCATE (Zvec, opihi_flt, NPTS);
    144144      }
    145145      if ((Npts > NCHUNK) || (Nloaded >= 25)) {

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

    r20820 r20839  
    1414  unsigned photFlagChoice, photFlagClip;
    1515  int PhotcodeClip;
    16   float *Xvec, *Yvec, *Zvec;
     16  opihi_flt *Xvec, *Yvec, *Zvec;
    1717  time_t tzero, tend;
    1818  void *Signal;
    … …  
    169169  Npts = 0;
    170170  NPTS = 1000;
    171   ALLOCATE (Xvec, float, NPTS);
    172   ALLOCATE (Yvec, float, NPTS);
    173   ALLOCATE (Zvec, float, NPTS);
     171  ALLOCATE (Xvec, opihi_flt, NPTS);
     172  ALLOCATE (Yvec, opihi_flt, NPTS);
     173  ALLOCATE (Zvec, opihi_flt, NPTS);
    174174
    175175  // prepare to handle interrupt signals
    … …  
    218218          free (date);
    219219        }
    220         status = fRD_to_XY (&Xvec[Npts], &Yvec[Npts], R, D, &graphmode.coords);
     220        status = RD_to_XY (&Xvec[Npts], &Yvec[Npts], R, D, &graphmode.coords);
    221221        if (!status) continue;
    222222        Npts ++;
    … …  
    224224        if (Npts == NPTS - 1) {
    225225            NPTS += 1000;
    226             REALLOCATE (Xvec, float, NPTS);
    227             REALLOCATE (Yvec, float, NPTS);
    228             REALLOCATE (Zvec, float, NPTS);
     226            REALLOCATE (Xvec, opihi_flt, NPTS);
     227            REALLOCATE (Yvec, opihi_flt, NPTS);
     228            REALLOCATE (Zvec, opihi_flt, NPTS);
    229229        }
    230230        if ((Npts > NCHUNK) || (Nloaded >= 25)) {

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

    r19823 r20839  
    9696  /* data has been loaded, get ready to plot it */
    9797  Yvec.Nelements = Xvec.Nelements = 3*Nrocks;
    98   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    99   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
     98  ALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     99  ALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    100100 
    101101  /* project stars to screen display coords */
    … …  
    106106      while (rocks[i].ra[j] < Rmin) rocks[i].ra[j] += 360.0;
    107107      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);
     108      RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], rocks[i].ra[j], rocks[i].dec[j], &graphmode.coords);
    109109      N ++;
    110110    }
    … …  
    114114  graphmode.style = 2; /* set style to points */
    115115  graphmode.etype = 0; /* no errorbars */
    116   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     116  PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    117117
    118118  /* now plot vectors between two extrema */
    119119  Yvec.Nelements = Xvec.Nelements = 2*Nrocks;
    120   REALLOCATE (Xvec.elements, float, Xvec.Nelements);
    121   REALLOCATE (Yvec.elements, float, Yvec.Nelements);
     120  REALLOCATE (Xvec.elements.Flt, opihi_flt, Xvec.Nelements);
     121  REALLOCATE (Yvec.elements.Flt, opihi_flt, Yvec.Nelements);
    122122 
    123123  /* project stars to screen display coords */
    … …  
    136136    while (rocks[i].ra[N1] < Rmin) rocks[i].ra[N1] += 360.0;
    137137    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);
     138    RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], rocks[i].ra[N0], rocks[i].dec[N0], &graphmode.coords);
    139139    N ++;
    140     fRD_to_XY (&Xvec.elements[N], &Yvec.elements[N], rocks[i].ra[N1], rocks[i].dec[N1], &graphmode.coords);
     140    RD_to_XY (&Xvec.elements.Flt[N], &Yvec.elements.Flt[N], rocks[i].ra[N1], rocks[i].dec[N1], &graphmode.coords);
    141141    N ++;
    142142  }
    … …  
    147147  graphmode.etype = 0; /* no errorbars */
    148148
    149   PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     149  PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    150150
    151   free (Xvec.elements);
    152   free (Yvec.elements);
     151  free (Xvec.elements.Flt);
     152  free (Yvec.elements.Flt);
    153153  return (TRUE);
    154154

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

    r13479 r20839  
    2222  N = 0;
    2323  NPTS = 200;
    24   ALLOCATE (Xvec.elements, float, NPTS);
    25   ALLOCATE (Yvec.elements, float, NPTS);
     24  ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     25  ALLOCATE (Yvec.elements.Flt, 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    }
    … …  
    8686    graphmode.ptype = 100; /* connect pairs of points */
    8787    graphmode.etype = 0;
    88     PlotVectorPair (kapa, N, Xvec.elements, Yvec.elements, &graphmode);
     88    PlotVectorPair (kapa, N, Xvec.elements.Flt, Yvec.elements.Flt, &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

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

    r13479 r20839  
    9595  Yvec.Nelements = Nstars;
    9696  Zvec.Nelements = Nstars;
    97   ALLOCATE (Xvec.elements, float, Xvec.Nelements);
    98   ALLOCATE (Yvec.elements, float, Yvec.Nelements);
    99   ALLOCATE (Zvec.elements, float, Zvec.Nelements);
     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);
    100100  ALLOCATE (buffer, char, (BLOCK*BYTES_STAR));
    101101
    … …  
    107107    if (nbytes != BLOCK*BYTES_STAR) {
    108108      gprint (GP_ERR, "failed to read in stars (1)\n");
    109       free (Xvec.elements);
    110       free (Yvec.elements);
    111       free (Zvec.elements);
     109      free (Xvec.elements.Flt);
     110      free (Yvec.elements.Flt);
     111      free (Zvec.elements.Flt);
    112112      free (buffer);
    113113      return (FALSE);
    … …  
    118118      dparse (&M,  3, &buffer[j*BYTES_STAR]);
    119119      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));
     120      RD_to_XY (&Xvec.elements.Flt[nstars], &Yvec.elements.Flt[nstars], R, D, &graphmode.coords);
     121      Zvec.elements.Flt[nstars] = MIN (1.0, MAX (0.01, (M - zero) / range));
    122122    }
    123123  }
    … …  
    126126  if (nbytes != (Nbytes % (BLOCK*BYTES_STAR))) {
    127127    gprint (GP_ERR, "ERROR: failed to read in stars (2)\n");
    128     free (Xvec.elements);
    129     free (Yvec.elements);
    130     free (Zvec.elements);
     128    free (Xvec.elements.Flt);
     129    free (Yvec.elements.Flt);
     130    free (Zvec.elements.Flt);
    131131    free (buffer);
    132132    return (FALSE);
    … …  
    137137    dparse (&M,  3, &buffer[j*BYTES_STAR]);
    138138    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));
     139    RD_to_XY (&Xvec.elements.Flt[nstars], &Yvec.elements.Flt[nstars], R, D, &graphmode.coords);
     140    Zvec.elements.Flt[nstars] = MIN (1.0, MAX (0.01, (M - zero) / range));
    141141  }
    142142 
    143143  if (nstars != Nstars) {
    144144    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);
     145    free (Xvec.elements.Flt);
     146    free (Yvec.elements.Flt);
     147    free (Zvec.elements.Flt);
    148148    free (buffer);
    149149    return (FALSE);
    … …  
    155155  Npts = Xvec.Nelements;
    156156
    157   PlotVectorTriplet (kapa, Npts, Xvec.elements, Yvec.elements, Zvec.elements, &graphmode);
     157  PlotVectorTriplet (kapa, Npts, Xvec.elements.Flt, Yvec.elements.Flt, Zvec.elements.Flt, &graphmode);
    158158
    159   free (Xvec.elements);
    160   free (Yvec.elements);
    161   free (Zvec.elements);
     159  free (Xvec.elements.Flt);
     160  free (Yvec.elements.Flt);
     161  free (Zvec.elements.Flt);
    162162  free (buffer);
    163163

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

    r20820 r20839  
    5454
    5555  NPTS = 200;
    56   ALLOCATE (Xvec.elements, float, NPTS);
    57   ALLOCATE (Yvec.elements, float, NPTS);
     56  ALLOCATE (Xvec.elements.Flt, opihi_flt, NPTS);
     57  ALLOCATE (Yvec.elements.Flt, opihi_flt, NPTS);
    5858  Npts = 0;
    5959   
    … …  
    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    }
    … …  
    101101    graphmode.ptype = 100; /* connect pairs of points */
    102102    graphmode.etype = 0;
    103     PlotVectorPair (kapa, Npts, Xvec.elements, Yvec.elements, &graphmode);
     103    PlotVectorPair (kapa, Npts, Xvec.elements.Flt, Yvec.elements.Flt, &graphmode);
    104104  }
    105105
    106   free (Xvec.elements);
    107   free (Yvec.elements);
     106  free (Xvec.elements.Flt);
     107  free (Yvec.elements.Flt);
    108108  free (regions);
    109109

  • branches/eam_branch_20081124/Ohana/src/opihi/include/data.h

    r17419 r20839  
    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 */

  • branches/eam_branch_20081124/Ohana/src/opihi/include/display.h

    r13479 r20839  
    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, int Npts, opihi_flt *values, char *mode));
     10int           PlotVectorPair        PROTO((int kapa, int Npts, opihi_flt *xValues, opihi_flt *yValues, Graphdata *graphmode));
     11int           PlotVectorPairErrors  PROTO((int kapa, int Npts, opihi_flt *xValues, opihi_flt *yValues, opihi_flt *dyValues, Graphdata *graphmode));
     12int           PlotVectorTriplet     PROTO((int kapa, int Npts, opihi_flt *xValues, opihi_flt *yValues, opihi_flt *zValues, Graphdata *graphmode));
    1013int           GetGraphData          PROTO((Graphdata *data, int *kapa, char *name));
    1114int           GetGraph              PROTO((Graphdata *data, int *kapa, char *name));

  • branches/eam_branch_20081124/Ohana/src/opihi/include/dvomath.h

    r20827 r20839  
    44# define DVOMATH_H
    55
     6# define OPIHI_NAME_SIZE 1024
     7
    68# define NCHARS 256
    7 # define opihi_float float
     9# define opihi_flt double
    810# define opihi_int unsigned int
    911
    1012enum {ANYVECTOR, NEWVECTOR, OLDVECTOR};
    1113enum {ANYBUFFER, NEWBUFFER, OLDBUFFER};
    12 enum {OPIHI_FLOAT, OPIHI_INT};
     14enum {OPIHI_FLT, OPIHI_INT};
    1315
    1416typedef struct {                        /* representation of a variable (0-D) */
    … …  
    1820
    1921typedef struct {                        /* representation of a vector (1-D) */
    20   char name[1024];
     22  char name[OPIHI_NAME_SIZE];
    2123  char type;
    22   float *elements;
    23   unsigned int *elementsInt;
     24  union {
     25    void      *Ptr;
     26    opihi_flt *Flt;
     27    opihi_int *Int;
     28  } elements;
    2429  int Nelements;
    2530} Vector;
    2631
    2732typedef struct {                        /* representation of buffer (image) */
    28   char name[1024];
    29   char file[1024];
     33  char name[OPIHI_NAME_SIZE];
     34  char file[OPIHI_NAME_SIZE];
    3035  Header header;
    3136  Matrix matrix;
    … …  
    3742  char   *name;
    3843  char    type;
    39   float  *ptr;
    4044  Buffer *buffer;
    4145  Vector *vector;
    42   float   Float;
     46  opihi_flt FltValue;
     47  opihi_int IntValue;
    4348} StackVar;
    4449

  • branches/eam_branch_20081124/Ohana/src/opihi/include/dvoshell.h

    r20820 r20839  
    225225// dvo DB field functions
    226226dbField     *dbCmdlineFields        PROTO((int argc, char **argv, int table, int *last, int *nfields));
     227int          dbCmdlineConditions    PROTO((int argc, char **argv, int first, int *nextField));
    227228dbStack     *dbRPN                  PROTO((int argc, char **argv, int *nstack));
    228229int          dbCheckStack           PROTO((dbStack *stack, int Nstack, int table, dbField **inFields, int *Nfields));

  • branches/eam_branch_20081124/Ohana/src/opihi/include/imfit.h

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

  • branches/eam_branch_20081124/Ohana/src/opihi/include/pantasks.h

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

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

    r13479 r20839  
    11# include "display.h"
    22
    3 int PlotVectorPair (int kapa, int Npts, float *xValues, float *yValues, Graphdata *graphmode) {
     3int PlotVectorSingle (int kapa, int Npts, opihi_flt *values, char *mode) {
    44
    5   KapaPrepPlot (kapa, Npts, graphmode);
    6   KapaPlotVector (kapa, Npts, xValues, "x");
    7   KapaPlotVector (kapa, Npts, yValues, "y");
     5  int i;
     6  float *temp;
     7  ALLOCATE (temp, float, Npts);
     8
     9  for (i = 0; i < Npts; i++) {
     10    temp[i] = values[i];
     11  }
     12  KapaPlotVector (kapa, Npts, temp, mode);
     13
     14  free (temp);
    815
    916  return (TRUE);
    1017}
    1118
    12 int PlotVectorTriplet (int kapa, int Npts, float *xValues, float *yValues, float *zValues, Graphdata *graphmode) {
     19int PlotVectorPair (int kapa, int Npts, opihi_flt *xValues, opihi_flt *yValues, Graphdata *graphmode) {
    1320
    14   KapaPrepPlot   (kapa, Npts, graphmode);
    15   KapaPlotVector (kapa, Npts, xValues, "x");
    16   KapaPlotVector (kapa, Npts, yValues, "y");
    17   KapaPlotVector (kapa, Npts, zValues, "z");
     21  int i;
     22  float *temp;
     23  ALLOCATE (temp, float, Npts);
     24
     25  KapaPrepPlot (kapa, Npts, graphmode);
     26
     27  for (i = 0; i < Npts; i++) {
     28    temp[i] = xValues[i];
     29  }
     30  KapaPlotVector (kapa, Npts, temp, "x");
     31
     32  for (i = 0; i < Npts; i++) {
     33    temp[i] = yValues[i];
     34  }
     35  KapaPlotVector (kapa, Npts, temp, "y");
     36
     37  free (temp);
    1838
    1939  return (TRUE);
    2040}
     41
     42int PlotVectorTriplet (int kapa, int Npts, opihi_flt *xValues, opihi_flt *yValues, opihi_flt *zValues, Graphdata *graphmode) {
     43
     44  int i;
     45  float *temp;
     46  ALLOCATE (temp, float, Npts);
     47
     48  KapaPrepPlot   (kapa, Npts, graphmode);
     49
     50  for (i = 0; i < Npts; i++) {
     51    temp[i] = xValues[i];
     52  }
     53  KapaPlotVector (kapa, Npts, temp, "x");
     54
     55  for (i = 0; i < Npts; i++) {
     56    temp[i] = yValues[i];
     57  }
     58  KapaPlotVector (kapa, Npts, temp, "y");
     59
     60  for (i = 0; i < Npts; i++) {
     61    temp[i] = zValues[i];
     62  }
     63  KapaPlotVector (kapa, Npts, temp, "z");
     64
     65  free (temp);
     66
     67  return (TRUE);
     68}
     69
     70int PlotVectorPairErrors (int kapa, int Npts, opihi_flt *xValues, opihi_flt *yValues, opihi_flt *dyValues, Graphdata *graphmode) {
     71
     72  int i;
     73  float *temp;
     74  ALLOCATE (temp, float, Npts);
     75
     76  KapaPrepPlot (kapa, Npts, graphmode);
     77
     78  for (i = 0; i < Npts; i++) {
     79    temp[i] = xValues[i];
     80  }
     81  KapaPlotVector (kapa, Npts, temp, "x");
     82
     83  for (i = 0; i < Npts; i++) {
     84    temp[i] = yValues[i];
     85  }
     86  KapaPlotVector (kapa, Npts, temp, "y");
     87
     88  for (i = 0; i < Npts; i++) {
     89    temp[i] = dyValues[i];
     90  }
     91  KapaPlotVector (kapa, Npts, temp, "dym");
     92  KapaPlotVector (kapa, Npts, temp, "dyp");
     93
     94  free (temp);
     95
     96  return (TRUE);
     97}
     98

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

    r17902 r20839  
    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) {

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

    r13479 r20839  
    11# include "data.h"
    22
     3// XXX need to select the active vector for the range analysis
    34void SetLimits (Vector *xvec, Vector *yvec, Graphdata *graphmode) {
    45
    … …  
    78
    89  if (xvec != NULL) {
    9     maxX = minX = xvec[0].elements[0];
     10    maxX = minX = xvec[0].elements.Flt[0];
    1011    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]);
     12      if (!finite(xvec[0].elements.Flt[i])) continue;
     13      maxX = MAX (maxX, xvec[0].elements.Flt[i]);
     14      minX = MIN (minX, xvec[0].elements.Flt[i]);
    1415    }
    1516    range = maxX - minX;
    … …  
    2122
    2223  if (yvec != NULL) {
    23     maxY = minY = yvec[0].elements[0];
     24    maxY = minY = yvec[0].elements.Flt[0];
    2425    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]);
     26      if (!finite(yvec[0].elements.Flt[i])) continue;
     27      maxY = MAX (maxY, yvec[0].elements.Flt[i]);
     28      minY = MIN (minY, yvec[0].elements.Flt[i]);
    2829    }
    2930    range = maxY - minY;

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

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

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

    r16059 r20839  
    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}

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

    r19827 r20839  
    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;

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

    r4689 r20839  
    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;

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

    r20827 r20839  
    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     if (vectors[i][0].elements) {
    21       free (vectors[i][0].elements);
    22     }
    23     if (vectors[i][0].elementsInt) {
    24       free (vectors[i][0].elementsInt);
     22    if (vectors[i][0].elements.Int) {
     23      free (vectors[i][0].elements.Int);
    2524    }
    2625    free (vectors[i]);
    … …  
    3433  ALLOCATE (vec, Vector, 1);
    3534
    36   vec[0].elementsInt = NULL;
    37   ALLOCATE (vec[0].elements, opihi_float, 1);
    38   vec[0].type = OPIHI_FLOAT;                      /* is a float unless specified otherwise */
    39 
    40   bzero (vec[0].name, 1024);
     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);
    4139  vec[0].Nelements = 0;
    4240  return (vec);
    … …  
    104102  if (i == Nvectors) return (FALSE);
    105103
    106   if (vectors[i][0].elements)    free (vectors[i][0].elements);
    107   if (vectors[i][0].elementsInt) free (vectors[i][0].elementsInt);
     104  if (vectors[i][0].elements.Ptr) free (vectors[i][0].elements.Ptr);
    108105  free (vectors[i]);
    109106
    … …  
    125122  if (i == Nvectors) return (FALSE);
    126123
    127   if (vectors[i][0].elements)    free (vectors[i][0].elements);
    128   if (vectors[i][0].elementsInt) free (vectors[i][0].elementsInt);
     124  if (vectors[i][0].elements.Ptr) free (vectors[i][0].elements.Ptr);
    129125  free (vectors[i]);
    130126
    … …  
    145141  return (TRUE);
    146142}
     143
    147144int CopyVector (Vector *out, Vector *in) {
    148   free (out[0].elements);
     145  if (out[0].elements.Ptr) free (out[0].elements.Ptr);
    149146  out[0].Nelements = in[0].Nelements;
    150   if (in[0].elements) {
    151     assert (in[0].type == OPIHI_FLOAT);
    152     ALLOCATE (out[0].elements, opihi_float, out[0].Nelements);
    153     memcpy (out[0].elements, in[0].elements, out[0].Nelements*sizeof(opihi_float));
    154     out[0].type = OPIHI_FLOAT;
    155   } else {
    156     assert (in[0].type == OPIHI_INT);
    157     ALLOCATE (out[0].elementsInt, opihi_int, out[0].Nelements);
    158     memcpy (out[0].elementsInt, in[0].elementsInt, out[0].Nelements*sizeof(opihi_int));
    159     out[0].type = OPIHI_INT;
     147  if (in[0].elements.Ptr) {
     148    if (in[0].type == OPIHI_FLT) {
     149      ALLOCATE (out[0].elements.Flt, opihi_flt, out[0].Nelements);
     150      memcpy (out[0].elements.Flt, in[0].elements.Flt, out[0].Nelements*sizeof(opihi_flt));
     151      out[0].type = OPIHI_FLT;
     152    } else {
     153      ALLOCATE (out[0].elements.Int, opihi_int, out[0].Nelements);
     154      memcpy (out[0].elements.Int, in[0].elements.Int, out[0].Nelements*sizeof(opihi_int));
     155      out[0].type = OPIHI_INT;
     156    }
    160157  }
    161158  return (TRUE);
    … …  
    170167  return (TRUE);
    171168}
     169
    172170int MoveVector (Vector *out, Vector *in) {
    173171  int i, j;
    174172
    175   free (out[0].elements);
    176   out[0].Nelements   = in[0].Nelements;
    177   out[0].elements    = in[0].elements;
    178   out[0].elementsInt = in[0].elementsInt;
    179   out[0].type        = in[0].type;
     173  if (out[0].elements.Ptr) free (out[0].elements.Ptr);
     174  out[0].Nelements    = in[0].Nelements;
     175  out[0].elements.Ptr = in[0].elements.Ptr;
     176  out[0].type         = in[0].type;
    180177
    181178  /* delete vector entry from vector list, if it exists */

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

    r6250 r20839  
    1212
    1313      /** if this is a number, put it on the list of scalers and move on **/
    14       stack[i].Float = strtod (stack[i].name, &c);
     14      // XXX need to handle IntValue vs FltValue
     15      stack[i].FltValue = strtod (stack[i].name, &c);
    1516      if (c == stack[i].name + strlen (stack[i].name)) {
    16         stack[i].ptr   = &(stack[i].Float);
    1717        stack[i].type  = 'S';
    1818        continue;
    … …  
    2222      if (IsBuffer (stack[i].name)) {
    2323        stack[i].buffer = SelectBuffer (stack[i].name, OLDBUFFER, TRUE);
    24         stack[i].ptr    = (float *) stack[i].buffer[0].matrix.buffer;
    2524        stack[i].type   = 'M';
    2625        if (Nx == -1) {
    … …  
    4443      if (IsVector (stack[i].name)) {
    4544        stack[i].vector = SelectVector (stack[i].name, OLDVECTOR, FALSE);
    46         stack[i].ptr    = (float *) stack[i].vector[0].elements;
    4745        stack[i].type   = 'V';
    4846

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

    r14708 r20839  
    7979          sprintf (outname, "%s", stack[0].name);
    8080      } else {
    81           sprintf (outname, "%.12g", stack[0].Float);
     81          sprintf (outname, "%.12g", stack[0].FltValue);
    8282      }
    8383      break;

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

    r18078 r20839  
    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;

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

    r17247 r20839  
    126126        }
    127127        if (I < 0) I += vec[0].Nelements;
    128         f1 = vec[0].elements[I];
     128        f1 = vec[0].elements.Flt[I];
    129129      }
    130130    }

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

    r16059 r20839  
    190190      }
    191191      if (Nx < 0) Nx += vec[0].Nelements;
    192       vec[0].elements[Nx] = atof (val);
     192      vec[0].elements.Flt[Nx] = atof (val);
    193193    }
    194194

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

    r20827 r20839  
    99
    1010  int i, Nx;
    11   float *out, *M1, *M2;
    1211  char line[512]; // this is only used to report an error
    1312 
     13  // the vectors have to match in length
     14  if (V1[0].vector[0].Nelements != V2[0].vector[0].Nelements) {
     15    return (FALSE);
     16  }
     17
    1418  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;
    36 
    37 // XXX this is not quite there:
    38 // 1) do I drop the .ptr element of StackVar?
    39 // 2) things below are using type from a StackVar to get the vector type -- wrong place
    40 // 3) the temp would need lots of work -- is it worth it?
    41 // 4) some operators force the output to be float -- we cannot use a single bit of code to
    42 //    define the output type based on which is a float and which is not.  getting ugly.
    43 // ??? how much more work to bring the MV, etc functions into shape ???
    44 
     19
     20  // XXX we temporarily drop the concept of using one of the temporary input vectors for
     21  // the output vector (thus saving an ALLOC): we have to juggle the size of the input vectors
     22  // as well as their temporary state
     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
    4530# define VV_FUNC(OP) \
    46   if ((M1->type == OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) { \
    47     // output must be float, can use either as a temp \
    48     opihi_float *M1 = V1[0].vector[0].elements; \
    49     opihi_float *M2 = V2[0].vector[0].elements; \
     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; \
    5036    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    51         *out = *M1 OP *M2; \
     37        *out = OP; \
    5238    } \
    5339    break; \
    5440  } \
    55   if ((M1->type != OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) { \
    56     // output must be float, can use M2 as a temp \
    57     opihi_float *M1 = V1[0].vector[0].elementsInt; \
    58     opihi_float *M2 = V2[0].vector[0].elements; \
     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; \
    5946    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    60         *out = *M1 OP *M2; \
     47        *out = OP; \
    6148    } \
    6249    break; \
    6350  } \
    64   if ((M1->type == OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) { \
    65     // output must be float, can use M1 as a temp \
    66     opihi_float *M1 = V1[0].vector[0].elements; \
    67     opihi_float *M2 = V2[0].vector[0].elementsInt; \
     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; \
    6856    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    69         *out = *M1 OP *M2; \
     57        *out = OP; \
    7058    } \
    7159    break; \
    7260  } \
    73   if ((M1->type != OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) { \
    74     // output may be int, can use either as temp \
    75     opihi_float *M1 = V1[0].vector[0].elementsInt; \
    76     opihi_float *M2 = V2[0].vector[0].elementsInt; \
     61  if ((V1->vector->type != OPIHI_FLT) && (V2->vector->type != OPIHI_FLT)) { \
     62    CopyVector (OUT[0].vector, V1[0].vector); \
     63    opihi_int *M1  =  V1[0].vector[0].elements.Int; \
     64    opihi_int *M2  =  V2[0].vector[0].elements.Int; \
     65    opihi_int *out = OUT[0].vector[0].elements.Int; \
    7766    for (i = 0; i < Nx; i++, out++, M1++, M2++) { \
    78         *out = *M1 OP *M2; \
     67        *out = OP; \
    7968    } \
    8069    break; \
    … …  
    8271
    8372  switch (op[0]) {
    84   case '+':
    85     VV_FUNC
    86 
    87     if ((M1->type == OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) {
    88       // output must be float, can use either as a temp
    89       M1 = V1[0].vector[0].elements;
    90       M2 = V2[0].vector[0].elements;
    91       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    92         *out = *M1 + *M2;
    93       }
    94       break;
    95     }
    96     if ((M1->type != OPIHI_FLOAT) && (M2->type == OPIHI_FLOAT)) {
    97       // output must be float, can use M2 as a temp
    98       M1 = V1[0].vector[0].elementsInt;
    99       M2 = V2[0].vector[0].elements;
    100       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    101         *out = *M1 + *M2;
    102       }
    103       break;
    104     }
    105     if ((M1->type == OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) {
    106       // output must be float, can use M1 as a temp
    107       M1 = V1[0].vector[0].elements;
    108       M2 = V2[0].vector[0].elementsInt;
    109       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    110         *out = *M1 + *M2;
    111       }
    112       break;
    113     }
    114     if ((M1->type != OPIHI_FLOAT) && (M2->type != OPIHI_FLOAT)) {
    115       // output may be int, can use either as temp
    116       M1 = V1[0].vector[0].elementsInt;
    117       M2 = V2[0].vector[0].elementsInt;
    118       for (i = 0; i < Nx; i++, out++, M1++, M2++) {
    119         *out = *M1 + *M2;
    120       }
    121       break;
    122     }
    123   case '-':
    124     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    125       *out = *M1 - *M2;
    126     break;
    127   case '*':
    128     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    129       *out = *M1 * *M2;
    130     break;
    131   case '/':
    132     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    133       *out = *M1 / *M2;
    134     break;
    135   case '%':
    136     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    137       *out = (int) *M1 % (int) *M2;
    138     break;
    139   case 0x5e:
    140     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    141       *out = pow (*M1, *M2);
    142     break;
    143   case '@':
    144     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    145       *out = DEG_RAD*atan2 (*M1, *M2);
    146     break;
    147   case 'D':
    148     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    149       *out = MIN (*M1, *M2);
    150     break;
    151   case 'U':
    152     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    153       *out = MAX (*M1, *M2);
    154     break;
    155   case '<':
    156     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    157       *out = (*M1 < *M2) ? 1 : 0;
    158     break;
    159   case '>':
    160     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    161       *out = (*M1 > *M2) ? 1 : 0;
    162     break;
    163   case '&':
    164     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    165       *out = ((int)*M1 & (int)*M2);
    166     break;
    167   case '|':
    168     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    169       *out = ((int)*M1 | (int)*M2);
    170     break;
    171   case 'E':
    172     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    173       *out = (*M1 == *M2) ? 1 : 0;
    174     break;
    175   case 'N':
    176     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    177       *out = (*M1 != *M2) ? 1 : 0;
    178     break;
    179   case 'L':
    180     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    181       *out = (*M1 <= *M2) ? 1 : 0;
    182     break;
    183   case 'G':
    184     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    185       *out = (*M1 >= *M2) ? 1 : 0;
    186     break;
    187   case 'A':
    188     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    189       *out = (*M1 && *M2) ? 1 : 0;
    190     break;
    191   case 'O':
    192     for (i = 0; i < Nx; i++, out++, M1++, M2++)
    193       *out = (*M1 || *M2) ? 1 : 0;
    194     break;
     73    case '+': VV_FUNC(*M1 + *M2);
     74    case '-': VV_FUNC(*M1 - *M2);
     75    case '*': VV_FUNC(*M1 * *M2);
     76    case '/': VV_FUNC(*M1 / *M2);
     77    case '%': VV_FUNC((int)*M1 % (int)*M2);
     78    case '^': VV_FUNC(pow (*M1, *M2));
     79    case '@': VV_FUNC(DEG_RAD*atan2 (*M1, *M2));
     80    case 'D': VV_FUNC(MIN (*M1, *M2));
     81    case 'U': VV_FUNC(MAX (*M1, *M2));
     82    case '<': VV_FUNC((*M1 < *M2) ? 1 : 0);
     83    case '>': VV_FUNC((*M1 > *M2) ? 1 : 0);
     84    case '&': VV_FUNC(((int)*M1 & (int)*M2));
     85    case '|': VV_FUNC(((int)*M1 | (int)*M2));
     86    case 'E': VV_FUNC((*M1 == *M2) ? 1 : 0);
     87    case 'N': VV_FUNC((*M1 != *M2) ? 1 : 0);
     88    case 'L': VV_FUNC((*M1 <= *M2) ? 1 : 0);
     89    case 'G': VV_FUNC((*M1 >= *M2) ? 1 : 0);
     90    case 'A': VV_FUNC((*M1 && *M2) ? 1 : 0);
     91    case 'O': VV_FUNC((*M1 || *M2) ? 1 : 0);
    19592  default:
    19693    sprintf (line, "error: op %c not defined!", op[0]);
    … …  
    19895    return (FALSE);
    19996  }
     97# undef VV_FUNC
    20098
    20199  /** free up any temporary buffers: **/
    202100
    203101  if (V1[0].type == 'v') {
    204     free (V1[0].vector[0].elements);
     102    free (V1[0].vector[0].elements.Ptr);
    205103    free (V1[0].vector);
    206104  }
    207105  if (V2[0].type == 'v') {
    208     free (V2[0].vector[0].elements);
     106    free (V2[0].vector[0].elements.Ptr);
    209107    free (V2[0].vector);
    210108  }
    … …  
    220118
    221119  int i, Nx;
    222   float *out, *M1, *M2;
    223120  char line[512]; // this is only used to report an error
    224121 
    … …  
    234131  OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
    235132
    236   M1  = V1[0].ptr;
    237   M2  = V2[0].ptr;
    238   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     133  opihi_flt  M1  = V1[0].FltValue;
     134  opihi_flt *M2  = V2[0].vector[0].elements.Flt;
     135  opihi_flt *out = OUT[0].vector[0].elements.Flt;
     136
     137# define SV_FUNC(OP) \
     138    for (i = 0; i < Nx; i++, out++, M2++) \
     139      *out = OP; \
     140    break;
    239141
    240142  switch (op[0]) {
    241   case '+':
    242     for (i = 0; i < Nx; i++, out++, M2++)
    243       *out = *M1 + *M2;
    244     break;
    245   case '-':
    246     for (i = 0; i < Nx; i++, out++, M2++)
    247       *out = *M1 - *M2;
    248     break;
    249   case '*':
    250     for (i = 0; i < Nx; i++, out++, M2++)
    251       *out = *M1 * *M2;
    252     break;
    253   case '/':
    254     for (i = 0; i < Nx; i++, out++, M2++)
    255       *out = *M1 / *M2;
    256     break;
    257   case '%':
    258     for (i = 0; i < Nx; i++, out++, M2++)
    259       *out = (int) *M1 % (int) *M2;
    260     break;
    261   case 0x5e:
    262     for (i = 0; i < Nx; i++, out++, M2++)
    263       *out = pow (*M1, *M2);
    264     break;
    265   case '@':
    266     for (i = 0; i < Nx; i++, out++, M2++)
    267       *out = DEG_RAD*atan2 (*M1, *M2);
    268     break;
    269   case 'D':
    270     for (i = 0; i < Nx; i++, out++, M2++)
    271       *out = MIN (*M1, *M2);
    272     break;
    273   case 'U':
    274     for (i = 0; i < Nx; i++, out++, M2++)
    275       *out = MAX (*M1, *M2);
    276     break;
    277   case '<':
    278     for (i = 0; i < Nx; i++, out++, M2++)
    279       *out = (*M1 < *M2) ? 1 : 0;
    280     break;
    281   case '>':
    282     for (i = 0; i < Nx; i++, out++, M2++)
    283       *out = (*M1 > *M2) ? 1 : 0;
    284     break;
    285   case '&':
    286     for (i = 0; i < Nx; i++, out++, M2++)
    287       *out = ((int)*M1 & (int)*M2);
    288     break;
    289   case '|':
    290     for (i = 0; i < Nx; i++, out++, M2++)
    291       *out = ((int)*M1 | (int)*M2);
    292     break;
    293   case 'E':
    294     for (i = 0; i < Nx; i++, out++, M2++)
    295       *out = (*M1 == *M2) ? 1 : 0;
    296     break;
    297   case 'N':
    298     for (i = 0; i < Nx; i++, out++, M2++)
    299       *out = (*M1 != *M2) ? 1 : 0;
    300     break;
    301   case 'L':
    302     for (i = 0; i < Nx; i++, out++, M2++)
    303       *out = (*M1 <= *M2) ? 1 : 0;
    304     break;
    305   case 'G':
    306     for (i = 0; i < Nx; i++, out++, M2++)
    307       *out = (*M1 >= *M2) ? 1 : 0;
    308     break;
    309   case 'A':
    310     for (i = 0; i < Nx; i++, out++, M2++)
    311       *out = (*M1 && *M2) ? 1 : 0;
    312     break;
    313   case 'O':
    314     for (i = 0; i < Nx; i++, out++, M2++)
    315       *out = (*M1 || *M2) ? 1 : 0;
    316     break;
    317   default:
    318     sprintf (line, "error: op %c not defined!", op[0]);
    319     push_error (line);
    320     return (FALSE);
    321   }
     143    case '+': SV_FUNC(M1 + *M2);
     144    case '-': SV_FUNC(M1 - *M2);
     145    case '*': SV_FUNC(M1 * *M2);
     146    case '/': SV_FUNC(M1 / *M2);
     147    case '%': SV_FUNC((int) M1 % (int) *M2);
     148    case '^': SV_FUNC(pow (M1, *M2));
     149    case '@': SV_FUNC(DEG_RAD*atan2 (M1, *M2));
     150    case 'D': SV_FUNC(MIN (M1, *M2));
     151    case 'U': SV_FUNC(MAX (M1, *M2));
     152    case '<': SV_FUNC((M1 < *M2) ? 1 : 0);
     153    case '>': SV_FUNC((M1 > *M2) ? 1 : 0);
     154    case '&': SV_FUNC(((int)M1 & (int)*M2));
     155    case '|': SV_FUNC(((int)M1 | (int)*M2));
     156    case 'E': SV_FUNC((M1 == *M2) ? 1 : 0);
     157    case 'N': SV_FUNC((M1 != *M2) ? 1 : 0);
     158    case 'L': SV_FUNC((M1 <= *M2) ? 1 : 0);
     159    case 'G': SV_FUNC((M1 >= *M2) ? 1 : 0);
     160    case 'A': SV_FUNC((M1 && *M2) ? 1 : 0);
     161    case 'O': SV_FUNC((M1 || *M2) ? 1 : 0);
     162    default:
     163      sprintf (line, "error: op %c not defined!", op[0]);
     164      push_error (line);
     165      return (FALSE);
     166  }
     167# undef SV_FUNC
    322168
    323169  /** free up any temporary buffers: **/
    324170  if (V2[0].type == 'v') {
    325     free (V2[0].vector[0].elements);
     171    free (V2[0].vector[0].elements.Ptr);
    326172    free (V2[0].vector);
    327173  }
    … …  
    338184
    339185  int i, Nx;
    340   float *out, *M1, *M2;
    341186  char line[512]; // this is only used to report an error
    342187 
    … …  
    352197  OUT[0].type = 'v';   /*** <<--- says this is a temporary matrix ***/
    353198
    354   M1  = V1[0].ptr;
    355   M2  = V2[0].ptr;
    356   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     199  opihi_flt *M1  = V1[0].vector[0].elements.Flt;
     200  opihi_flt  M2  = V2[0].FltValue;
     201  opihi_flt *out = OUT[0].vector[0].elements.Flt;
     202
     203# define VS_FUNC(OP) \
     204    for (i = 0; i < Nx; i++, out++, M1++) \
     205      *out = OP; \
     206    break;
    357207
    358208  switch (op[0]) {
    359   case '+':
    360     for (i = 0; i < Nx; i++, out++, M1++)
    361       *out = *M1 + *M2;
    362     break;
    363   case '-':
    364     for (i = 0; i < Nx; i++, out++, M1++)
    365       *out = *M1 - *M2;
    366     break;
    367   case '*':
    368     for (i = 0; i < Nx; i++, out++, M1++)
    369       *out = *M1 * *M2;
    370     break;
    371   case '/':
    372     for (i = 0; i < Nx; i++, out++, M1++)
    373       *out = *M1 / *M2;
    374     break;
    375   case '%':
    376     for (i = 0; i < Nx; i++, out++, M1++)
    377       *out = (int) *M1 % (int) *M2;
    378     break;
    379   case 0x5e:
    380     for (i = 0; i < Nx; i++, out++, M1++)
    381       *out = pow (*M1, *M2);
    382     break;
    383   case '@':
    384     for (i = 0; i < Nx; i++, out++, M1++)
    385       *out = DEG_RAD*atan2 (*M1, *M2);
    386     break;
    387   case 'D':
    388     for (i = 0; i < Nx; i++, out++, M1++)
    389       *out = MIN (*M1, *M2);
    390     break;
    391   case 'U':
    392     for (i = 0; i < Nx; i++, out++, M1++)
    393       *out = MAX (*M1, *M2);
    394     break;
    395   case '<':
    396     for (i = 0; i < Nx; i++, out++, M1++)
    397       *out = (*M1 < *M2) ? 1 : 0;
    398     break;
    399   case '>':
    400     for (i = 0; i < Nx; i++, out++, M1++)
    401       *out = (*M1 > *M2) ? 1 : 0;
    402     break;
    403   case '&':
    404     for (i = 0; i < Nx; i++, out++, M1++)
    405       *out = ((int)*M1 & (int)*M2);
    406     break;
    407   case '|':
    408     for (i = 0; i < Nx; i++, out++, M1++)
    409       *out = ((int)*M1 | (int)*M2);
    410     break;
    411   case 'E':
    412     for (i = 0; i < Nx; i++, out++, M1++)
    413       *out = (*M1 == *M2) ? 1 : 0;
    414     break;
    415   case 'N':
    416     for (i = 0; i < Nx; i++, out++, M1++)
    417       *out = (*M1 != *M2) ? 1 : 0;
    418     break;
    419   case 'L':
    420     for (i = 0; i < Nx; i++, out++, M1++)
    421       *out = (*M1 <= *M2) ? 1 : 0;
    422     break;
    423   case 'G':
    424     for (i = 0; i < Nx; i++, out++, M1++)
    425       *out = (*M1 >= *M2) ? 1 : 0;
    426     break;
    427   case 'A':
    428     for (i = 0; i < Nx; i++, out++, M1++)
    429       *out = (*M1 && *M2) ? 1 : 0;
    430     break;
    431   case 'O':
    432     for (i = 0; i < Nx; i++, out++, M1++)
    433       *out = (*M1 || *M2) ? 1 : 0;
    434     break;
    435   default:
    436     sprintf (line, "error: op %c not defined!", op[0]);
    437     push_error (line);
    438     return (FALSE);
    439   }
     209    case '+': VS_FUNC(*M1 + M2);
     210    case '-': VS_FUNC(*M1 - M2);
     211    case '*': VS_FUNC(*M1 * M2);
     212    case '/': VS_FUNC(*M1 / M2);
     213    case '%': VS_FUNC((int) *M1 % (int) M2);
     214    case '^': VS_FUNC(pow (*M1, M2));
     215    case '@': VS_FUNC(DEG_RAD*atan2 (*M1, M2));
     216    case 'D': VS_FUNC(MIN (*M1, M2));
     217    case 'U': VS_FUNC(MAX (*M1, M2));
     218    case '<': VS_FUNC((*M1 < M2) ? 1 : 0);
     219    case '>': VS_FUNC((*M1 > M2) ? 1 : 0);
     220    case '&': VS_FUNC(((int)*M1 & (int)M2));
     221    case '|': VS_FUNC(((int)*M1 | (int)M2));
     222    case 'E': VS_FUNC((*M1 == M2) ? 1 : 0);
     223    case 'N': VS_FUNC((*M1 != M2) ? 1 : 0);
     224    case 'L': VS_FUNC((*M1 <= M2) ? 1 : 0);
     225    case 'G': VS_FUNC((*M1 >= M2) ? 1 : 0);
     226    case 'A': VS_FUNC((*M1 && M2) ? 1 : 0);
     227    case 'O': VS_FUNC((*M1 || M2) ? 1 : 0);
     228    default:
     229      sprintf (line, "error: op %c not defined!", op[0]);
     230      push_error (line);
     231      return (FALSE);
     232  }
     233# undef VS_FUNC
    440234
    441235  /** free up any temporary buffers: **/
    442236
    443237  if (V1[0].type == 'v') {
    444     free (V1[0].vector[0].elements);
     238    free (V1[0].vector[0].elements.Ptr);
    445239    free (V1[0].vector);
    446240  }
    … …  
    454248}
    455249
     250// the vector is applied to each column
    456251int MV_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    457252
    458253  int i, j, Nx, Ny;
    459   float *out, *M1, *M2;
    460254  char line[512]; // this is only used to report an error
    461255 
    … …  
    478272  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    479273
    480   M1  = V1[0].ptr;
    481   M2  = V2[0].ptr;
    482   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     274  float     *M1  = (float *) V1[0].buffer[0].matrix.buffer;
     275  opihi_flt *M2  = V2[0].vector[0].elements.Flt;
     276  float     *out = (float *)OUT[0].buffer[0].matrix.buffer;
     277
     278# define MV_FUNC(OP) \
     279    for (i = 0; i < Ny; i++, M2++) { \
     280      for (j = 0; j < Nx; j++, out++, M1++) { \
     281        *out = OP; \
     282      } \
     283    } \
     284    break;
    483285
    484286  switch (op[0]) {
    485   case '+':
    486     for (i = 0; i < Ny; i++, M2++) {
    487       for (j = 0; j < Nx; j++, out++, M1++)
    488         *out = *M1 + *M2;
    489     }
    490     break;
    491   case '-':
    492     for (i = 0; i < Ny; i++, M2++) {
    493       for (j = 0; j < Nx; j++, out++, M1++)
    494         *out = *M1 - *M2;
    495     }
    496     break;
    497   case '*':
    498     for (i = 0; i < Ny; i++, M2++) {
    499       for (j = 0; j < Nx; j++, out++, M1++)
    500         *out = *M1 * *M2;
    501     }
    502     break;
    503   case '/':
    504     for (i = 0; i < Ny; i++, M2++) {
    505       for (j = 0; j < Nx; j++, out++, M1++)
    506         *out = *M1 / *M2;
    507     }
    508     break;
    509   case '%':
    510     for (i = 0; i < Ny; i++, M2++) {
    511       for (j = 0; j < Nx; j++, out++, M1++)
    512         *out = (int) *M1 % (int) *M2;
    513     }
    514     break;
    515   case 0x5e:
    516     for (i = 0; i < Ny; i++, M2++) {
    517       for (j = 0; j < Nx; j++, out++, M1++)
    518         *out = pow (*M1, *M2);
    519     }
    520     break;
    521   case '@':
    522     for (i = 0; i < Ny; i++, M2++) {
    523       for (j = 0; j < Nx; j++, out++, M1++)
    524         *out = DEG_RAD*atan2 (*M1, *M2);
    525     }
    526     break;
    527   case 'D':
    528     for (i = 0; i < Ny; i++, M2++) {
    529       for (j = 0; j < Nx; j++, out++, M1++)
    530         *out = MIN (*M1, *M2);
    531     }
    532     break;
    533   case 'U':
    534     for (i = 0; i < Ny; i++, M2++) {
    535       for (j = 0; j < Nx; j++, out++, M1++)
    536         *out = MAX (*M1, *M2);
    537     }
    538     break;
    539   case '<':
    540     for (i = 0; i < Ny; i++, M2++) {
    541       for (j = 0; j < Nx; j++, out++, M1++)
    542         *out = (*M1 < *M2) ? 1 : 0;
    543     }
    544     break;
    545   case '>':
    546     for (i = 0; i < Ny; i++, M2++) {
    547       for (j = 0; j < Nx; j++, out++, M1++)
    548         *out = (*M1 > *M2) ? 1 : 0;
    549     }
    550     break;
    551   case '&':
    552     for (i = 0; i < Ny; i++, M2++) {
    553       for (j = 0; j < Nx; j++, out++, M1++)
    554         *out = ((int)*M1 & (int)*M2);
    555     }
    556     break;
    557   case '|':
    558     for (i = 0; i < Ny; i++, M2++) {
    559       for (j = 0; j < Nx; j++, out++, M1++)
    560         *out = ((int)*M1 | (int)*M2);
    561     }
    562     break;
    563   case 'E':
    564     for (i = 0; i < Ny; i++, M2++) {
    565       for (j = 0; j < Nx; j++, out++, M1++)
    566         *out = (*M1 == *M2) ? 1 : 0;
    567     }
    568     break;
    569   case 'N':
    570     for (i = 0; i < Ny; i++, M2++) {
    571       for (j = 0; j < Nx; j++, out++, M1++)
    572         *out = (*M1 != *M2) ? 1 : 0;
    573     }
    574     break;
    575   case 'L':
    576     for (i = 0; i < Ny; i++, M2++) {
    577       for (j = 0; j < Nx; j++, out++, M1++)
    578         *out = (*M1 <= *M2) ? 1 : 0;
    579     }
    580     break;
    581   case 'G':
    582     for (i = 0; i < Ny; i++, M2++) {
    583       for (j = 0; j < Nx; j++, out++, M1++)
    584         *out = (*M1 >= *M2) ? 1 : 0;
    585     }
    586     break;
    587   case 'A':
    588     for (i = 0; i < Ny; i++, M2++) {
    589       for (j = 0; j < Nx; j++, out++, M1++)
    590         *out = (*M1 && *M2) ? 1 : 0;
    591     }
    592     break;
    593   case 'O':
    594     for (i = 0; i < Ny; i++, M2++) {
    595       for (j = 0; j < Nx; j++, out++, M1++)
    596         *out = (*M1 || *M2) ? 1 : 0;
    597     }
    598     break;
    599   default:
    600     sprintf (line, "error: op %c not defined!", op[0]);
    601     push_error (line);
    602     return (FALSE);
     287    case '+': MV_FUNC(*M1 + *M2);
     288    case '-': MV_FUNC(*M1 - *M2);
     289    case '*': MV_FUNC(*M1 * *M2);
     290    case '/': MV_FUNC(*M1 / *M2);
     291    case '%': MV_FUNC((int) *M1 % (int) *M2);
     292    case '^': MV_FUNC(pow (*M1, *M2));
     293    case '@': MV_FUNC(DEG_RAD*atan2 (*M1, *M2));
     294    case 'D': MV_FUNC(MIN (*M1, *M2));
     295    case 'U': MV_FUNC(MAX (*M1, *M2));
     296    case '<': MV_FUNC((*M1 < *M2) ? 1 : 0);
     297    case '>': MV_FUNC((*M1 > *M2) ? 1 : 0);
     298    case '&': MV_FUNC(((int)*M1 & (int)*M2));
     299    case '|': MV_FUNC(((int)*M1 | (int)*M2));
     300    case 'E': MV_FUNC((*M1 == *M2) ? 1 : 0);
     301    case 'N': MV_FUNC((*M1 != *M2) ? 1 : 0);
     302    case 'L': MV_FUNC((*M1 <= *M2) ? 1 : 0);
     303    case 'G': MV_FUNC((*M1 >= *M2) ? 1 : 0);
     304    case 'A': MV_FUNC((*M1 && *M2) ? 1 : 0);
     305    case 'O': MV_FUNC((*M1 || *M2) ? 1 : 0);
     306    default:
     307      sprintf (line, "error: op %c not defined!", op[0]);
     308      push_error (line);
     309      return (FALSE);
    603310  }
    604311
    … …  
    611318  }
    612319  if (V2[0].type == 'v') {
    613     free (V2[0].vector[0].elements);
     320    free (V2[0].vector[0].elements.Ptr);
    614321    free (V2[0].vector);
    615322  }
    … …  
    620327  /* at the end, V1 and V2 are deleted only if they were temporary */
    621328  return (TRUE);
    622 
    623 }
    624 
    625 
     329}
     330
     331// the vector is applied to each row
    626332int VM_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    627333
    628334  int i, j, Nx, Ny;
    629   float *out, *M1, *M2;
    630335  char line[512]; // this is only used to report an error
    631336 
    … …  
    646351  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    647352
    648   M1  = V1[0].ptr;
    649   M2  = V2[0].ptr;
    650   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     353  opihi_flt *M1  = V1[0].vector[0].elements.Flt;
     354  float     *M2  = (float *) V2[0].buffer[0].matrix.buffer;
     355  float     *out = (float *)OUT[0].buffer[0].matrix.buffer;
     356
     357# define VM_FUNC(OP) \
     358    for (i = 0; i < Ny; i++) { \
     359      M1  = V1[0].vector[0].elements.Flt; \
     360      for (j = 0; j < Nx; j++, out++, M1++, M2++) { \
     361        *out = OP; \
     362      } \
     363    } \
     364    break;
    651365
    652366  switch (op[0]) {
    653   case '+':
    654     for (i = 0; i < Ny; i++) {
    655       M1 = V1[0].ptr;
    656       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    657         *out = *M1 + *M2;
    658     }
    659     break;
    660   case '-':
    661     for (i = 0; i < Ny; i++) {
    662       M1 = V1[0].ptr;
    663       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    664         *out = *M1 - *M2;
    665     }
    666     break;
    667   case '*':
    668     for (i = 0; i < Ny; i++) {
    669       M1 = V1[0].ptr;
    670       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    671         *out = *M1 * *M2;
    672     }
    673     break;
    674   case '/':
    675     for (i = 0; i < Ny; i++) {
    676       M1 = V1[0].ptr;
    677       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    678         *out = *M1 / *M2;
    679     }
    680     break;
    681   case '%':
    682     for (i = 0; i < Ny; i++) {
    683       M1 = V1[0].ptr;
    684       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    685         *out = (int) *M1 % (int) *M2;
    686     }
    687     break;
    688   case 0x5e:
    689     for (i = 0; i < Ny; i++) {
    690       M1 = V1[0].ptr;
    691       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    692         *out = pow (*M1, *M2);
    693     }
    694     break;
    695   case '@':
    696     for (i = 0; i < Ny; i++) {
    697       M1 = V1[0].ptr;
    698       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    699         *out = DEG_RAD*atan2 (*M1, *M2);
    700     }
    701     break;
    702   case 'D':
    703     for (i = 0; i < Ny; i++) {
    704       M1 = V1[0].ptr;
    705       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    706         *out = MIN (*M1, *M2);
    707     }
    708     break;
    709   case 'U':
    710     for (i = 0; i < Ny; i++) {
    711       M1 = V1[0].ptr;
    712       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    713         *out = MAX (*M1, *M2);
    714     }
    715     break;
    716   case '<':
    717     for (i = 0; i < Ny; i++) {
    718       M1 = V1[0].ptr;
    719       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    720         *out = (*M1 < *M2) ? 1 : 0;
    721     }
    722     break;
    723   case '>':
    724     for (i = 0; i < Ny; i++) {
    725       M1 = V1[0].ptr;
    726       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    727         *out = (*M1 > *M2) ? 1 : 0;
    728     }
    729     break;
    730   case '&':
    731     for (i = 0; i < Ny; i++) {
    732       M1 = V1[0].ptr;
    733       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    734         *out = ((int)*M1 & (int)*M2);
    735     }
    736     break;
    737   case '|':
    738     for (i = 0; i < Ny; i++) {
    739       M1 = V1[0].ptr;
    740       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    741         *out = ((int)*M1 | (int)*M2);
    742     }
    743     break;
    744   case 'E':
    745     for (i = 0; i < Ny; i++) {
    746       M1 = V1[0].ptr;
    747       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    748         *out = (*M1 == *M2) ? 1 : 0;
    749     }
    750     break;
    751   case 'N':
    752     for (i = 0; i < Ny; i++) {
    753       M1 = V1[0].ptr;
    754       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    755         *out = (*M1 != *M2) ? 1 : 0;
    756     }
    757     break;
    758   case 'L':
    759     for (i = 0; i < Ny; i++) {
    760       M1 = V1[0].ptr;
    761       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    762         *out = (*M1 <= *M2) ? 1 : 0;
    763     }
    764     break;
    765   case 'G':
    766     for (i = 0; i < Ny; i++) {
    767       M1 = V1[0].ptr;
    768       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    769         *out = (*M1 >= *M2) ? 1 : 0;
    770     }
    771     break;
    772   case 'A':
    773     for (i = 0; i < Ny; i++) {
    774       M1 = V1[0].ptr;
    775       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    776         *out = (*M1 && *M2) ? 1 : 0;
    777     }
    778     break;
    779   case 'O':
    780     for (i = 0; i < Ny; i++) {
    781       M1 = V1[0].ptr;
    782       for (j = 0; j < Nx; j++, out++, M1++, M2++)
    783         *out = (*M1 || *M2) ? 1 : 0;
    784     }
    785     break;
    786   default:
    787     sprintf (line, "error: op %c not defined!", op[0]);
    788     push_error (line);
    789     return (FALSE);
     367    case '+': VM_FUNC(*M1 + *M2);
     368    case '-': VM_FUNC(*M1 - *M2);
     369    case '*': VM_FUNC(*M1 * *M2);
     370    case '/': VM_FUNC(*M1 / *M2);
     371    case '%': VM_FUNC((int) *M1 % (int) *M2);
     372    case '^': VM_FUNC(pow (*M1, *M2));
     373    case '@': VM_FUNC(DEG_RAD*atan2 (*M1, *M2));
     374    case 'D': VM_FUNC(MIN (*M1, *M2));
     375    case 'U': VM_FUNC(MAX (*M1, *M2));
     376    case '<': VM_FUNC((*M1 < *M2) ? 1 : 0);
     377    case '>': VM_FUNC((*M1 > *M2) ? 1 : 0);
     378    case '&': VM_FUNC(((int)*M1 & (int)*M2));
     379    case '|': VM_FUNC(((int)*M1 | (int)*M2));
     380    case 'E': VM_FUNC((*M1 == *M2) ? 1 : 0);
     381    case 'N': VM_FUNC((*M1 != *M2) ? 1 : 0);
     382    case 'L': VM_FUNC((*M1 <= *M2) ? 1 : 0);
     383    case 'G': VM_FUNC((*M1 >= *M2) ? 1 : 0);
     384    case 'A': VM_FUNC((*M1 && *M2) ? 1 : 0);
     385    case 'O': VM_FUNC((*M1 || *M2) ? 1 : 0);
     386    default:
     387      sprintf (line, "error: op %c not defined!", op[0]);
     388      push_error (line);
     389      return (FALSE);
    790390  }
    791391
    … …  
    793393
    794394  if (V1[0].type == 'v') {
    795     free (V1[0].vector[0].elements);
     395    free (V1[0].vector[0].elements.Ptr);
    796396    free (V1[0].vector);
    797397  }
    … …  
    833433  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    834434
    835   M1  = V1[0].ptr;
    836   M2  = V2[0].ptr;
    837   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     435  M1  = (float *)V1[0].buffer[0].matrix.buffer;
     436  M2  = (float *)V2[0].buffer[0].matrix.buffer;
     437  out = (float *)OUT[0].buffer[0].matrix.buffer;
    838438
    839439  switch (op[0]) {
    … …  
    945545
    946546  int i, Nx, Ny;
    947   float *out, *M1, *M2;
     547  float *out, *M1;
     548  opihi_flt M2;
    948549  char line[512]; // this is only used to report an error
    949550 
    … …  
    961562  OUT[0].type = 'm';      /*** <<--- says this is a temporary matrix ***/
    962563
    963   M1  = V1[0].ptr;
    964   M2  = V2[0].ptr;
    965   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     564  M1  = (float *)V1[0].buffer[0].matrix.buffer;
     565  M2  = V2[0].FltValue;
     566  out = (float *)OUT[0].buffer[0].matrix.buffer;
    966567
    967568  switch (op[0]) {
    968569  case '+':
    969570    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    970       *out = *M1 + *M2;
     571      *out = *M1 + M2;
    971572    break;
    972573  case '-':
    973574    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    974       *out = *M1 - *M2;
     575      *out = *M1 - M2;
    975576    break;
    976577  case '*':
    977578    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    978       *out = *M1 * *M2;
     579      *out = *M1 * M2;
    979580    break;
    980581  case '/':
    981582    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    982       *out = *M1 / *M2;
     583      *out = *M1 / M2;
    983584    break;
    984585  case '%':
    985586    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    986       *out = (int) *M1 % (int) *M2;
     587      *out = (int) *M1 % (int) M2;
    987588    break;
    988589  case 0x5e:
    989590    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    990       *out = pow (*M1, *M2);
     591      *out = pow (*M1, M2);
    991592    break;
    992593  case '@':
    993594    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    994       *out = DEG_RAD*atan2 (*M1, *M2);
     595      *out = DEG_RAD*atan2 (*M1, M2);
    995596    break;
    996597  case 'D':
    997598    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    998       *out = MIN (*M1, *M2);
     599      *out = MIN (*M1, M2);
    999600    break;
    1000601  case 'U':
    1001602    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1002       *out = MAX (*M1, *M2);
     603      *out = MAX (*M1, M2);
    1003604    break;
    1004605  case '<':
    1005606    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1006       *out = (*M1 < *M2) ? 1 : 0;
     607      *out = (*M1 < M2) ? 1 : 0;
    1007608    break;
    1008609  case '>':
    1009610    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1010       *out = (*M1 > *M2) ? 1 : 0;
     611      *out = (*M1 > M2) ? 1 : 0;
    1011612    break;
    1012613  case '&':
    1013614    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1014       *out = ((int)*M1 & (int)*M2);
     615      *out = ((int)*M1 & (int)M2);
    1015616    break;
    1016617  case '|':
    1017618    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1018       *out = ((int)*M1 | (int)*M2);
     619      *out = ((int)*M1 | (int)M2);
    1019620    break;
    1020621  case 'E':
    1021622    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1022       *out = (*M1 == *M2) ? 1 : 0;
     623      *out = (*M1 == M2) ? 1 : 0;
    1023624    break;
    1024625  case 'N':
    1025626    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1026       *out = (*M1 != *M2) ? 1 : 0;
     627      *out = (*M1 != M2) ? 1 : 0;
    1027628    break;
    1028629  case 'L':
    1029630    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1030       *out = (*M1 <= *M2) ? 1 : 0;
     631      *out = (*M1 <= M2) ? 1 : 0;
    1031632    break;
    1032633  case 'G':
    1033634    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1034       *out = (*M1 >= *M2) ? 1 : 0;
     635      *out = (*M1 >= M2) ? 1 : 0;
    1035636    break;
    1036637  case 'A':
    1037638    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1038       *out = (*M1 && *M2) ? 1 : 0;
     639      *out = (*M1 && M2) ? 1 : 0;
    1039640    break;
    1040641  case 'O':
    1041642    for (i = 0; i < Nx*Ny; i++, out++, M1++)
    1042       *out = (*M1 || *M2) ? 1 : 0;
     643      *out = (*M1 || M2) ? 1 : 0;
    1043644    break;
    1044645  default:
    … …  
    1064665
    1065666  int i, Nx, Ny;
    1066   float *out, *M1, *M2;
     667  float *out, *M2;
     668  opihi_flt M1;
    1067669  char line[512]; // this is only used to report an error
    1068670 
    … …  
    1079681  OUT[0].type = 'm'; /*** <<--- says this is a temporary matrix ***/
    1080682
    1081   M1  = V1[0].ptr;
    1082   M2  = V2[0].ptr;
    1083   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     683  M1  = V1[0].FltValue;
     684  M2  = (float *)OUT[0].buffer[0].matrix.buffer;
     685  out = (float *)OUT[0].buffer[0].matrix.buffer;
    1084686
    1085687  switch (op[0]) {
    1086688  case '+':
    1087689    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1088       *out = *M1 + *M2;
     690      *out = M1 + *M2;
    1089691    break;
    1090692  case '-':
    1091693    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1092       *out = *M1 - *M2;
     694      *out = M1 - *M2;
    1093695    break;
    1094696  case '*':
    1095697    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1096       *out = *M1 * *M2;
     698      *out = M1 * *M2;
    1097699    break;
    1098700  case '/':
    1099701    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1100       *out = *M1 / *M2;
     702      *out = M1 / *M2;
    1101703    break;
    1102704  case '%':
    1103705    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1104       *out = (int) *M1 % (int) *M2;
     706      *out = (int) M1 % (int) *M2;
    1105707    break;
    1106708  case 0x5e:
    1107709    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1108       *out = pow (*M1, *M2);
     710      *out = pow (M1, *M2);
    1109711    break;
    1110712  case '@':
    1111713    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1112       *out = DEG_RAD*atan2 (*M1, *M2);
     714      *out = DEG_RAD*atan2 (M1, *M2);
    1113715    break;
    1114716  case 'D':
    1115717    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1116       *out = MIN (*M1, *M2);
     718      *out = MIN (M1, *M2);
    1117719    break;
    1118720  case 'U':
    1119721    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1120       *out = MAX (*M1, *M2);
     722      *out = MAX (M1, *M2);
    1121723    break;
    1122724  case '<':
    1123725    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1124       *out = (*M1 < *M2) ? 1 : 0;
     726      *out = (M1 < *M2) ? 1 : 0;
    1125727    break;
    1126728  case '>':
    1127729    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1128       *out = (*M1 > *M2) ? 1 : 0;
     730      *out = (M1 > *M2) ? 1 : 0;
    1129731    break;
    1130732  case '&':
    1131733    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1132       *out = ((int)*M1 & (int)*M2);
     734      *out = ((int)M1 & (int)*M2);
    1133735    break;
    1134736  case '|':
    1135737    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1136       *out = ((int)*M1 | (int)*M2);
     738      *out = ((int)M1 | (int)*M2);
    1137739    break;
    1138740  case 'E':
    1139741    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1140       *out = (*M1 == *M2) ? 1 : 0;
     742      *out = (M1 == *M2) ? 1 : 0;
    1141743    break;
    1142744  case 'N':
    1143745    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1144       *out = (*M1 != *M2) ? 1 : 0;
     746      *out = (M1 != *M2) ? 1 : 0;
    1145747    break;
    1146748  case 'L':
    1147749    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1148       *out = (*M1 <= *M2) ? 1 : 0;
     750      *out = (M1 <= *M2) ? 1 : 0;
    1149751    break;
    1150752  case 'G':
    1151753    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1152       *out = (*M1 >= *M2) ? 1 : 0;
     754      *out = (M1 >= *M2) ? 1 : 0;
    1153755    break;
    1154756  case 'A':
    1155757    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1156       *out = (*M1 && *M2) ? 1 : 0;
     758      *out = (M1 && *M2) ? 1 : 0;
    1157759    break;
    1158760  case 'O':
    1159761    for (i = 0; i < Nx*Ny; i++, out++, M2++)
    1160       *out = (*M1 || *M2) ? 1 : 0;
     762      *out = (M1 || *M2) ? 1 : 0;
    1161763    break;
    1162764  default:
    … …  
    1181783int SS_binary (StackVar *OUT, StackVar *V1, StackVar *V2, char *op) {
    1182784
    1183   float *M1, *M2, *out;
     785  opihi_flt M1, M2;
    1184786  char line[512]; // this is only used to report an error
    1185787
    1186   M1  = V1[0].ptr;
    1187   M2  = V2[0].ptr;
    1188   OUT[0].ptr = V1[0].ptr;
    1189   out = OUT[0].ptr;
    1190 
     788  M1 = V1[0].FltValue;
     789  M2 = V2[0].FltValue;
     790  OUT[0].type = 'S';
    1191791
    1192792  switch (op[0]) {
    1193793  case '+':
    1194     *out = *M1 + *M2;
     794    OUT[0].FltValue = M1 + M2;
    1195795    break;   
    1196796  case '-':
    1197     *out = *M1 - *M2;
     797    OUT[0].FltValue = M1 - M2;
    1198798    break;   
    1199799  case '*':
    1200     *out = *M1 * *M2;
     800    OUT[0].FltValue = M1 * M2;
    1201801    break;   
    1202802  case '/':
    1203     *out = *M1 / *M2;
     803    OUT[0].FltValue = M1 / M2;
    1204804    break;
    1205805  case '%':
    1206     *out = (int) *M1 % (int) *M2;
     806    OUT[0].FltValue = (int) M1 % (int) M2;
    1207807    break;
    1208808  case 0x5e:
    1209     *out = pow (*M1, *M2);
     809    OUT[0].FltValue = pow (M1, M2);
    1210810    break;
    1211811  case '@':
    1212     *out = DEG_RAD*atan2 (*M1, *M2);
     812    OUT[0].FltValue = DEG_RAD*atan2 (M1, M2);
    1213813    break;
    1214814  case 'D':
    1215     *out = MIN (*M1, *M2);
     815    OUT[0].FltValue = MIN (M1, M2);
    1216816    break;
    1217817  case 'U':
    1218     *out = MAX (*M1, *M2);
     818    OUT[0].FltValue = MAX (M1, M2);
    1219819    break;
    1220820  case '<':
    1221     *out = (*M1 < *M2) ? 1 : 0;
     821    OUT[0].FltValue = (M1 < M2) ? 1 : 0;
    1222822    break;
    1223823  case '>':
    1224     *out = (*M1 > *M2) ? 1 : 0;
     824    OUT[0].FltValue = (M1 > M2) ? 1 : 0;
    1225825    break;
    1226826  case '&':
    1227     *out = ((int)*M1 & (int)*M2);
     827    OUT[0].FltValue = ((int)M1 & (int)M2);
    1228828    break;
    1229829  case '|':
    1230     *out = ((int)*M1 | (int)*M2);
     830    OUT[0].FltValue = ((int)M1 | (int)M2);
    1231831    break;
    1232832  case 'E':
    1233     *out = (*M1 == *M2) ? 1 : 0;
     833    OUT[0].FltValue = (M1 == M2) ? 1 : 0;
    1234834    break;
    1235835  case 'N':
    1236     *out = (*M1 != *M2) ? 1 : 0;
     836    OUT[0].FltValue = (M1 != M2) ? 1 : 0;
    1237837    break;
    1238838  case 'L':
    1239     *out = (*M1 <= *M2) ? 1 : 0;
     839    OUT[0].FltValue = (M1 <= M2) ? 1 : 0;
    1240840    break;
    1241841  case 'G':
    1242     *out = (*M1 >= *M2) ? 1 : 0;
     842    OUT[0].FltValue = (M1 >= M2) ? 1 : 0;
    1243843    break;
    1244844  case 'A':
    1245     *out = (*M1 && *M2) ? 1 : 0;
     845    OUT[0].FltValue = (M1 && M2) ? 1 : 0;
    1246846    break;
    1247847  case 'O':
    1248     *out = (*M1 || *M2) ? 1 : 0;
     848    OUT[0].FltValue = (M1 || M2) ? 1 : 0;
    1249849    break;
    1250850  default:
    … …  
    1253853    return (FALSE);
    1254854  }
    1255   OUT[0].Float = *(OUT[0].ptr);
    1256   OUT[0].type = 'S';
    1257855
    1258856  clear_stack (V1);
    … …  
    1304902
    1305903escape:
    1306   OUT[0].Float = value;
     904  OUT[0].FltValue = value;
    1307905  OUT[0].type = 'S';
    1308   OUT[0].ptr = &OUT[0].Float;
    1309906
    1310907  clear_stack (V1);
    … …  
    1317914int S_unary (StackVar *OUT, StackVar *V1, char *op) {
    1318915
    1319   float *out, *M1;
     916  opihi_flt M1;
    1320917 
    1321   out = OUT[0].ptr = V1[0].ptr;
    1322   M1  = V1[0].ptr;
     918  M1  = V1[0].FltValue;
     919  OUT[0].type = 'S';
    1323920
    1324921  if (!strcmp (op, "="))     {    }
    1325   if (!strcmp (op, "abs"))   {    *out = fabs(*M1);           }
    1326   if (!strcmp (op, "int"))   {    *out = (float)(int)(*M1);   }
    1327   if (!strcmp (op, "exp"))   {    *out = exp (*M1);           }
    1328   if (!strcmp (op, "ten"))   {    *out = pow (10.0,*M1);      }
    1329   if (!strcmp (op, "log"))   {    *out = log10 (*M1);         }
    1330   if (!strcmp (op, "ln"))    {    *out = log (*M1);           }
    1331   if (!strcmp (op, "sqrt"))  {    *out = sqrt (*M1);          }
    1332   if (!strcmp (op, "erf"))   {    *out = erf (*M1);           }
    1333 
    1334   if (!strcmp (op, "sinh"))  {    *out = sinh (*M1);          }
    1335   if (!strcmp (op, "cosh"))  {    *out = cosh (*M1);          }
    1336   if (!strcmp (op, "asinh")) {    *out = asinh (*M1);         }
    1337   if (!strcmp (op, "acosh")) {    *out = acosh (*M1);         }
    1338   if (!strcmp (op, "lgamma")) {   *out = lgamma (*M1);        }
    1339 
    1340   if (!strcmp (op, "sin"))   {    *out = sin (*M1);           }
    1341   if (!strcmp (op, "cos"))   {    *out = cos (*M1);           }
    1342   if (!strcmp (op, "tan"))   {    *out = tan (*M1);           }
    1343   if (!strcmp (op, "dsin"))  {    *out = sin (*M1*RAD_DEG);   }
    1344   if (!strcmp (op, "dcos"))  {    *out = cos (*M1*RAD_DEG);   }
    1345   if (!strcmp (op, "dtan"))  {    *out = tan (*M1*RAD_DEG);   }
    1346   if (!strcmp (op, "asin"))  {    *out = asin (*M1);          }
    1347   if (!strcmp (op, "acos"))  {    *out = acos (*M1);          }
    1348   if (!strcmp (op, "atan"))  {    *out = atan (*M1);          }
    1349   if (!strcmp (op, "dasin")) {    *out = asin (*M1)*DEG_RAD;  }
    1350   if (!strcmp (op, "dacos")) {    *out = acos (*M1)*DEG_RAD;  }
    1351   if (!strcmp (op, "datan")) {    *out = atan (*M1)*DEG_RAD;  }
    1352   if (!strcmp (op, "rnd"))   {    *out = drand48();           }
    1353   if (!strcmp (op, "not"))   {    *out = !(*M1);              }
    1354   if (!strcmp (op, "--"))    {    *out = - (*M1);             }
    1355   if (!strcmp (op, "isinf")) {    *out = !finite(*M1);        }
    1356   if (!strcmp (op, "isnan")) {    *out = isnan(*M1);          }
    1357 
    1358   OUT[0].Float = *out;
    1359   OUT[0].type = 'S';
     922  if (!strcmp (op, "abs"))   {    OUT[0].FltValue = fabs(M1);           }
     923  if (!strcmp (op, "int"))   {    OUT[0].FltValue = (float)(int)(M1);   }
     924  if (!strcmp (op, "exp"))   {    OUT[0].FltValue = exp (M1);           }
     925  if (!strcmp (op, "ten"))   {    OUT[0].FltValue = pow (10.0,M1);      }
     926  if (!strcmp (op, "log"))   {    OUT[0].FltValue = log10 (M1);         }
     927  if (!strcmp (op, "ln"))    {    OUT[0].FltValue = log (M1);           }
     928  if (!strcmp (op, "sqrt"))  {    OUT[0].FltValue = sqrt (M1);          }
     929  if (!strcmp (op, "erf"))   {    OUT[0].FltValue = erf (M1);           }
     930
     931  if (!strcmp (op, "sinh"))  {    OUT[0].FltValue = sinh (M1);          }
     932  if (!strcmp (op, "cosh"))  {    OUT[0].FltValue = cosh (M1);          }
     933  if (!strcmp (op, "asinh")) {    OUT[0].FltValue = asinh (M1);         }
     934  if (!strcmp (op, "acosh")) {    OUT[0].FltValue = acosh (M1);         }
     935  if (!strcmp (op, "lgamma")) {   OUT[0].FltValue = lgamma (M1);        }
     936
     937  if (!strcmp (op, "sin"))   {    OUT[0].FltValue = sin (M1);           }
     938  if (!strcmp (op, "cos"))   {    OUT[0].FltValue = cos (M1);           }
     939  if (!strcmp (op, "tan"))   {    OUT[0].FltValue = tan (M1);           }
     940  if (!strcmp (op, "dsin"))  {    OUT[0].FltValue = sin (M1*RAD_DEG);   }
     941  if (!strcmp (op, "dcos"))  {    OUT[0].FltValue = cos (M1*RAD_DEG);   }
     942  if (!strcmp (op, "dtan"))  {    OUT[0].FltValue = tan (M1*RAD_DEG);   }
     943  if (!strcmp (op, "asin"))  {    OUT[0].FltValue = asin (M1);          }
     944  if (!strcmp (op, "acos"))  {    OUT[0].FltValue = acos (M1);          }
     945  if (!strcmp (op, "atan"))  {    OUT[0].FltValue = atan (M1);          }
     946  if (!strcmp (op, "dasin")) {    OUT[0].FltValue = asin (M1)*DEG_RAD;  }
     947  if (!strcmp (op, "dacos")) {    OUT[0].FltValue = acos (M1)*DEG_RAD;  }
     948  if (!strcmp (op, "datan")) {    OUT[0].FltValue = atan (M1)*DEG_RAD;  }
     949  if (!strcmp (op, "rnd"))   {    OUT[0].FltValue = drand48();           }
     950  if (!strcmp (op, "not"))   {    OUT[0].FltValue = !(M1);              }
     951  if (!strcmp (op, "--"))    {    OUT[0].FltValue = - (M1);             }
     952  if (!strcmp (op, "isinf")) {    OUT[0].FltValue = !finite(M1);        }
     953  if (!strcmp (op, "isnan")) {    OUT[0].FltValue = isnan(M1);          }
    1360954
    1361955  clear_stack (V1);
    … …  
    1367961
    1368962  int i, Nx;
    1369   float *out, *M1;
    1370963 
    1371964  Nx = V1[0].vector[0].Nelements;
    … …  
    1379972  }
    1380973  OUT[0].type = 'v'; /*** <<--- says this is a temporary matrix ***/
    1381   M1  = V1[0].ptr;
    1382   out = OUT[0].ptr = (float *)OUT[0].vector[0].elements;
     974  opihi_flt *M1  = V1[0].vector[0].elements.Flt;
     975  opihi_flt *out = OUT[0].vector[0].elements.Flt;
    1383976
    1384977  if (!strcmp (op, "="))     { } /* already set equal */
    … …  
    14231016
    14241017  if (V1[0].type == 'v') {
    1425     free (V1[0].vector[0].elements);
     1018    free (V1[0].vector[0].elements.Ptr);
    14261019    free (V1[0].vector);
    14271020    V1[0].vector = NULL;
    … …  
    14491042  }
    14501043  OUT[0].type = 'm';      /*** <<--- says this is a temporary matrix ***/
    1451   M1  = V1[0].ptr;
    1452   out = OUT[0].ptr = (float *)OUT[0].buffer[0].matrix.buffer;
     1044  M1  = (float *) V1[0].buffer[0].matrix.buffer;
     1045  out = (float *)OUT[0].buffer[0].matrix.buffer;
    14531046
    14541047  if (!strcmp (op, "="))     { }

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

    r7917 r20839  
    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  REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (Npeak, 1));
     79  REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (Npeak, 1));
     80  REALLOCATE (vecz[0].elements.Flt, opihi_flt, MAX (Npeak, 1));
    8181  /* eliminate non-local peaks */
    8282  for (N = n = 0; n < Npeak; n++) {
    8383    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];
     84    vecx[0].elements.Flt[N] = xp[n];
     85    vecy[0].elements.Flt[N] = yp[n];
     86    vecz[0].elements.Flt[N] = zp[n];
    8787    N ++;
    8888  }
    … …  
    9292  free (keep);
    9393
    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));
     94  REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (N, 1));
     95  REALLOCATE (vecy[0].elements.Flt, opihi_flt, MAX (N, 1));
     96  REALLOCATE (vecz[0].elements.Flt, opihi_flt, MAX (N, 1));
    9797  vecx[0].Nelements = vecy[0].Nelements = vecz[0].Nelements = N;
    9898

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

    r16059 r20839  
    3232  */
    3333  for (i = 0; i < vecx[0].Nelements; i++) {
    34     x = vecx[0].elements[i] - xo;
    35     y = vecy[0].elements[i] - yo;
     34    x = vecx[0].elements.Flt[i] - xo;
     35    y = vecy[0].elements.Flt[i] - yo;
    3636    r = hypot (x, y);
    3737

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

    r7917 r20839  
    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);
     57  REALLOCATE (xc[0].elements.Flt, opihi_flt, Np);
     58  REALLOCATE (yc[0].elements.Flt, opihi_flt, Np);
     59  REALLOCATE (sx[0].elements.Flt, opihi_flt, Np);
     60  REALLOCATE (sy[0].elements.Flt, opihi_flt, Np);
     61  REALLOCATE (sxy[0].elements.Flt, opihi_flt, Np);
     62  REALLOCATE (zs[0].elements.Flt, opihi_flt, Np);
     63  REALLOCATE (zc[0].elements.Flt, opihi_flt, Np);
     64  REALLOCATE (sk[0].elements.Flt, opihi_flt, Np);
    6565  xc[0].Nelements = yc[0].Nelements = sx[0].Nelements = Np;
    6666  sy[0].Nelements = zs[0].Nelements = zc[0].Nelements = Np;
    … …  
    6969  v = (float *) buff[0].matrix.buffer;
    7070  for (i = 0; i < Np; i++) {
    71     x = xp[0].elements[i];
    72     y = yp[0].elements[i];
     71    x = xp[0].elements.Flt[i];
     72    y = yp[0].elements.Flt[i];
    7373    if (x < 0) continue;
    7474    if (x >= Nx) continue;
    … …  
    7777
    7878    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]);
     79                    &xc[0].elements.Flt[i],
     80                    &yc[0].elements.Flt[i],
     81                    &sx[0].elements.Flt[i],
     82                    &sy[0].elements.Flt[i],
     83                    &sxy[0].elements.Flt[i],
     84                    &zs[0].elements.Flt[i],
     85                    &zc[0].elements.Flt[i],
     86                    &sk[0].elements.Flt[i]);
    8787  }
    8888

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

    r7917 r20839  
    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  REALLOCATE (vecx[0].elements.Flt, opihi_flt, MAX (Npts, 1));
     25  REALLOCATE (vecy[0].elements.Flt, 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      }
Note: See TracChangeset for help on using the changeset viewer.