IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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

big update from eam_branch_20081124 with updates to Opihi math

Location:
trunk/Ohana/src/opihi/cmd.astro
Files:
25 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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