Ignore:
Timestamp:
Jan 31, 2012 12:13:39 PM (11 years ago)
Author:
srkline
Message:

Changes to the XOP code to upgrade to ToolKit? v6. Changes are the ones outlined in the Appendix A of the TK6 manual. SOme of the XOP support routines and the #pragma for 2-byte structures have changed. Per Howard Rodstein, there is no need to change the c files to cpp. c should work and compile just fine.

These changes work correctly on my mac. Next is to make sure that they work correctly on the two build machines.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sans/XOP_Dev/SANSAnalysis/XOP/Cylinder.c

    r507 r834  
    1515 
    1616Warning: 
    17 The call to WaveData() below returns a pointer to the middle 
     17The call to (float*)WaveData() below returns a pointer to the middle 
    1818of an unlocked Macintosh handle. In the unlikely event that your 
    1919calculations could cause memory to move, you should copy the coefficient 
     
    3636        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    3737                case NT_FP32: 
    38                         fp= WaveData(p->waveHandle); 
    39                         SetNaN64(&p->result); 
    40                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    41                 case NT_FP64: 
    42                         dp= WaveData(p->waveHandle); 
     38                        fp= (float*)WaveData(p->waveHandle); 
     39                        SetNaN64(&p->result); 
     40                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     41                case NT_FP64: 
     42                        dp= (double*)WaveData(p->waveHandle); 
    4343                        p->result = CylinderForm(dp,q); 
    4444                        return 0; 
     
    5656 
    5757Warning: 
    58 The call to WaveData() below returns a pointer to the middle 
     58The call to (float*)WaveData() below returns a pointer to the middle 
    5959of an unlocked Macintosh handle. In the unlikely event that your 
    6060calculations could cause memory to move, you should copy the coefficient 
     
    7777        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    7878                case NT_FP32: 
    79                         fp= WaveData(p->waveHandle); 
    80                         SetNaN64(&p->result); 
    81                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    82                 case NT_FP64: 
    83                         dp= WaveData(p->waveHandle); 
     79                        fp= (float*)WaveData(p->waveHandle); 
     80                        SetNaN64(&p->result); 
     81                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     82                case NT_FP64: 
     83                        dp= (double*)WaveData(p->waveHandle); 
    8484                        p->result = EllipCyl76(dp,q); 
    8585                        return 0; 
     
    9898 
    9999Warning: 
    100 The call to WaveData() below returns a pointer to the middle 
     100The call to (float*)WaveData() below returns a pointer to the middle 
    101101of an unlocked Macintosh handle. In the unlikely event that your 
    102102calculations could cause memory to move, you should copy the coefficient 
     
    119119        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    120120                case NT_FP32: 
    121                         fp= WaveData(p->waveHandle); 
    122                         fp= WaveData(p->waveHandle); 
    123                         SetNaN64(&p->result); 
    124                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    125                 case NT_FP64: 
    126                         dp= WaveData(p->waveHandle); 
     121                        fp= (float*)WaveData(p->waveHandle); 
     122                        fp= (float*)WaveData(p->waveHandle); 
     123                        SetNaN64(&p->result); 
     124                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     125                case NT_FP64: 
     126                        dp= (double*)WaveData(p->waveHandle); 
    127127                         
    128128                        p->result = EllipCyl20(dp,q); 
     
    141141 
    142142Warning: 
    143 The call to WaveData() below returns a pointer to the middle 
     143The call to (float*)WaveData() below returns a pointer to the middle 
    144144of an unlocked Macintosh handle. In the unlikely event that your 
    145145calculations could cause memory to move, you should copy the coefficient 
     
    162162        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    163163                case NT_FP32: 
    164                         fp= WaveData(p->waveHandle); 
    165                         SetNaN64(&p->result); 
    166                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    167                 case NT_FP64: 
    168                         dp= WaveData(p->waveHandle); 
     164                        fp= (float*)WaveData(p->waveHandle); 
     165                        SetNaN64(&p->result); 
     166                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     167                case NT_FP64: 
     168                        dp= (double*)WaveData(p->waveHandle); 
    169169                         
    170170                        p->result = TriaxialEllipsoid(dp,q); 
     
    184184 
    185185Warning: 
    186 The call to WaveData() below returns a pointer to the middle 
     186The call to (float*)WaveData() below returns a pointer to the middle 
    187187of an unlocked Macintosh handle. In the unlikely event that your 
    188188calculations could cause memory to move, you should copy the coefficient 
     
    205205        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    206206                case NT_FP32: 
    207                         fp= WaveData(p->waveHandle); 
    208                         SetNaN64(&p->result); 
    209                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    210                 case NT_FP64: 
    211                         dp= WaveData(p->waveHandle); 
     207                        fp= (float*)WaveData(p->waveHandle); 
     208                        SetNaN64(&p->result); 
     209                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     210                case NT_FP64: 
     211                        dp= (double*)WaveData(p->waveHandle); 
    212212                         
    213213                        p->result = Parallelepiped(dp,q); 
     
    227227 
    228228Warning: 
    229 The call to WaveData() below returns a pointer to the middle 
     229The call to (float*)WaveData() below returns a pointer to the middle 
    230230of an unlocked Macintosh handle. In the unlikely event that your 
    231231calculations could cause memory to move, you should copy the coefficient 
     
    248248        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    249249                case NT_FP32: 
    250                         fp= WaveData(p->waveHandle); 
    251                         SetNaN64(&p->result); 
    252                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    253                 case NT_FP64: 
    254                         dp= WaveData(p->waveHandle); 
     250                        fp= (float*)WaveData(p->waveHandle); 
     251                        SetNaN64(&p->result); 
     252                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     253                case NT_FP64: 
     254                        dp= (double*)WaveData(p->waveHandle); 
    255255                         
    256256                        p->result = HollowCylinder(dp,q); 
     
    270270 
    271271Warning: 
    272 The call to WaveData() below returns a pointer to the middle 
     272The call to (float*)WaveData() below returns a pointer to the middle 
    273273of an unlocked Macintosh handle. In the unlikely event that your 
    274274calculations could cause memory to move, you should copy the coefficient 
     
    291291        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    292292                case NT_FP32: 
    293                         fp= WaveData(p->waveHandle); 
    294                         SetNaN64(&p->result); 
    295                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    296                 case NT_FP64: 
    297                         dp= WaveData(p->waveHandle); 
     293                        fp= (float*)WaveData(p->waveHandle); 
     294                        SetNaN64(&p->result); 
     295                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     296                case NT_FP64: 
     297                        dp= (double*)WaveData(p->waveHandle); 
    298298                         
    299299                        p->result = EllipsoidForm(dp,q); 
     
    329329        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    330330                case NT_FP32: 
    331                         fp= WaveData(p->waveHandle); 
    332                         SetNaN64(&p->result); 
    333                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    334                 case NT_FP64: 
    335                         dp= WaveData(p->waveHandle); 
     331                        fp= (float*)WaveData(p->waveHandle); 
     332                        SetNaN64(&p->result); 
     333                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     334                case NT_FP64: 
     335                        dp= (double*)WaveData(p->waveHandle); 
    336336                         
    337337                        p->result = Cyl_PolyRadius(dp,q); 
     
    365365        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    366366                case NT_FP32: 
    367                         fp= WaveData(p->waveHandle); 
    368                         SetNaN64(&p->result); 
    369                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    370                 case NT_FP64: 
    371                         dp= WaveData(p->waveHandle); 
     367                        fp= (float*)WaveData(p->waveHandle); 
     368                        SetNaN64(&p->result); 
     369                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     370                case NT_FP64: 
     371                        dp= (double*)WaveData(p->waveHandle); 
    372372                         
    373373                        p->result = Cyl_PolyLength(dp,q); 
     
    403403        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    404404                case NT_FP32: 
    405                         fp= WaveData(p->waveHandle); 
    406                         SetNaN64(&p->result); 
    407                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    408                 case NT_FP64: 
    409                         dp= WaveData(p->waveHandle); 
     405                        fp= (float*)WaveData(p->waveHandle); 
     406                        SetNaN64(&p->result); 
     407                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     408                case NT_FP64: 
     409                        dp= (double*)WaveData(p->waveHandle); 
    410410                         
    411411                        p->result = CoreShellCylinder(dp,q); 
     
    440440        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    441441                case NT_FP32: 
    442                         fp= WaveData(p->waveHandle); 
    443                         SetNaN64(&p->result); 
    444                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    445                 case NT_FP64: 
    446                         dp= WaveData(p->waveHandle); 
     442                        fp= (float*)WaveData(p->waveHandle); 
     443                        SetNaN64(&p->result); 
     444                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     445                case NT_FP64: 
     446                        dp= (double*)WaveData(p->waveHandle); 
    447447                         
    448448                        p->result = PolyCoShCylinder(dp,q); 
     
    475475        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    476476                case NT_FP32: 
    477                         fp= WaveData(p->waveHandle); 
    478                         SetNaN64(&p->result); 
    479                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    480                 case NT_FP64: 
    481                         dp= WaveData(p->waveHandle); 
     477                        fp= (float*)WaveData(p->waveHandle); 
     478                        SetNaN64(&p->result); 
     479                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     480                case NT_FP64: 
     481                        dp= (double*)WaveData(p->waveHandle); 
    482482                         
    483483                        p->result = OblateForm(dp,q); 
     
    511511        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    512512                case NT_FP32: 
    513                         fp= WaveData(p->waveHandle); 
    514                         SetNaN64(&p->result); 
    515                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    516                 case NT_FP64: 
    517                         dp= WaveData(p->waveHandle); 
     513                        fp= (float*)WaveData(p->waveHandle); 
     514                        SetNaN64(&p->result); 
     515                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     516                case NT_FP64: 
     517                        dp= (double*)WaveData(p->waveHandle); 
    518518                         
    519519                        p->result = ProlateForm(dp,q); 
     
    547547        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    548548                case NT_FP32: 
    549                         fp= WaveData(p->waveHandle); 
    550                         SetNaN64(&p->result); 
    551                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    552                 case NT_FP64: 
    553                         dp= WaveData(p->waveHandle); 
     549                        fp= (float*)WaveData(p->waveHandle); 
     550                        SetNaN64(&p->result); 
     551                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     552                case NT_FP64: 
     553                        dp= (double*)WaveData(p->waveHandle); 
    554554                        p->result = StackedDiscs(dp,q); 
    555555                        return 0; 
     
    581581        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    582582                case NT_FP32: 
    583                         fp= WaveData(p->waveHandle); 
    584                         SetNaN64(&p->result); 
    585                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    586                 case NT_FP64: 
    587                         dp= WaveData(p->waveHandle); 
     583                        fp= (float*)WaveData(p->waveHandle); 
     584                        SetNaN64(&p->result); 
     585                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     586                case NT_FP64: 
     587                        dp= (double*)WaveData(p->waveHandle); 
    588588                        p->result = LamellarFF(dp,q); 
    589589                        return 0; 
     
    614614        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    615615                case NT_FP32: 
    616                         fp= WaveData(p->waveHandle); 
    617                         SetNaN64(&p->result); 
    618                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    619                 case NT_FP64: 
    620                         dp= WaveData(p->waveHandle); 
     616                        fp= (float*)WaveData(p->waveHandle); 
     617                        SetNaN64(&p->result); 
     618                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     619                case NT_FP64: 
     620                        dp= (double*)WaveData(p->waveHandle); 
    621621                        p->result = LamellarPS(dp,q); 
    622622                        return 0; 
     
    648648        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    649649                case NT_FP32: 
    650                         fp= WaveData(p->waveHandle); 
    651                         SetNaN64(&p->result); 
    652                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    653                 case NT_FP64: 
    654                         dp= WaveData(p->waveHandle); 
     650                        fp= (float*)WaveData(p->waveHandle); 
     651                        SetNaN64(&p->result); 
     652                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     653                case NT_FP64: 
     654                        dp= (double*)WaveData(p->waveHandle); 
    655655                        p->result = LamellarPS_HG(dp,q); 
    656656                        return 0; 
     
    682682        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    683683                case NT_FP32: 
    684                         fp= WaveData(p->waveHandle); 
    685                         SetNaN64(&p->result); 
    686                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    687                 case NT_FP64: 
    688                         dp= WaveData(p->waveHandle); 
     684                        fp= (float*)WaveData(p->waveHandle); 
     685                        SetNaN64(&p->result); 
     686                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     687                case NT_FP64: 
     688                        dp= (double*)WaveData(p->waveHandle); 
    689689                        p->result = LamellarFF_HG(dp,q); 
    690690                        return 0; 
     
    716716        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    717717                case NT_FP32: 
    718                         fp= WaveData(p->waveHandle); 
    719                         SetNaN64(&p->result); 
    720                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    721                 case NT_FP64: 
    722                         dp= WaveData(p->waveHandle); 
     718                        fp= (float*)WaveData(p->waveHandle); 
     719                        SetNaN64(&p->result); 
     720                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     721                case NT_FP64: 
     722                        dp= (double*)WaveData(p->waveHandle); 
    723723                        p->result = FlexExclVolCyl(dp,q); 
    724724                        return 0; 
     
    750750        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    751751                case NT_FP32: 
    752                         fp= WaveData(p->waveHandle); 
    753                         SetNaN64(&p->result); 
    754                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    755                 case NT_FP64: 
    756                         dp= WaveData(p->waveHandle); 
     752                        fp= (float*)WaveData(p->waveHandle); 
     753                        SetNaN64(&p->result); 
     754                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     755                case NT_FP64: 
     756                        dp= (double*)WaveData(p->waveHandle); 
    757757                        p->result = FlexCyl_Ellip(dp,q); 
    758758                        return 0; 
     
    784784        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    785785                case NT_FP32: 
    786                         fp= WaveData(p->waveHandle); 
    787                         SetNaN64(&p->result); 
    788                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    789                 case NT_FP64: 
    790                         dp= WaveData(p->waveHandle); 
     786                        fp= (float*)WaveData(p->waveHandle); 
     787                        SetNaN64(&p->result); 
     788                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     789                case NT_FP64: 
     790                        dp= (double*)WaveData(p->waveHandle); 
    791791                        p->result = FlexCyl_PolyLen(dp,q); 
    792792                        return 0; 
     
    818818        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    819819                case NT_FP32: 
    820                         fp= WaveData(p->waveHandle); 
    821                         SetNaN64(&p->result); 
    822                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    823                 case NT_FP64: 
    824                         dp= WaveData(p->waveHandle); 
     820                        fp= (float*)WaveData(p->waveHandle); 
     821                        SetNaN64(&p->result); 
     822                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     823                case NT_FP64: 
     824                        dp= (double*)WaveData(p->waveHandle); 
    825825                        p->result = FlexCyl_PolyRad(dp,q); 
    826826                        return 0; 
     
    851851        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    852852                case NT_FP32: 
    853                         fp= WaveData(p->waveHandle); 
    854                         SetNaN64(&p->result); 
    855                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    856                 case NT_FP64: 
    857                         dp= WaveData(p->waveHandle); 
     853                        fp= (float*)WaveData(p->waveHandle); 
     854                        SetNaN64(&p->result); 
     855                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     856                case NT_FP64: 
     857                        dp= (double*)WaveData(p->waveHandle); 
    858858                        p->result = Spherocylinder(dp,q); 
    859859                        return 0; 
     
    884884        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    885885                case NT_FP32: 
    886                         fp= WaveData(p->waveHandle); 
    887                         SetNaN64(&p->result); 
    888                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    889                 case NT_FP64: 
    890                         dp= WaveData(p->waveHandle); 
     886                        fp= (float*)WaveData(p->waveHandle); 
     887                        SetNaN64(&p->result); 
     888                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     889                case NT_FP64: 
     890                        dp= (double*)WaveData(p->waveHandle); 
    891891                        p->result = ConvexLens(dp,q); 
    892892                        return 0; 
     
    917917        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    918918                case NT_FP32: 
    919                         fp= WaveData(p->waveHandle); 
    920                         SetNaN64(&p->result); 
    921                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    922                 case NT_FP64: 
    923                         dp= WaveData(p->waveHandle); 
     919                        fp= (float*)WaveData(p->waveHandle); 
     920                        SetNaN64(&p->result); 
     921                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     922                case NT_FP64: 
     923                        dp= (double*)WaveData(p->waveHandle); 
    924924                        p->result = Dumbbell(dp,q); 
    925925                        return 0; 
     
    950950        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    951951                case NT_FP32: 
    952                         fp= WaveData(p->waveHandle); 
    953                         SetNaN64(&p->result); 
    954                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    955                 case NT_FP64: 
    956                         dp= WaveData(p->waveHandle); 
     952                        fp= (float*)WaveData(p->waveHandle); 
     953                        SetNaN64(&p->result); 
     954                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     955                case NT_FP64: 
     956                        dp= (double*)WaveData(p->waveHandle); 
    957957                        p->result = CappedCylinder(dp,q); 
    958958                        return 0; 
     
    983983        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    984984                case NT_FP32: 
    985                         fp= WaveData(p->waveHandle); 
    986                         SetNaN64(&p->result); 
    987                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    988                 case NT_FP64: 
    989                         dp= WaveData(p->waveHandle); 
     985                        fp= (float*)WaveData(p->waveHandle); 
     986                        SetNaN64(&p->result); 
     987                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     988                case NT_FP64: 
     989                        dp= (double*)WaveData(p->waveHandle); 
    990990                        p->result = Barbell(dp,q); 
    991991                        return 0; 
     
    10161016        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    10171017                case NT_FP32: 
    1018                         fp= WaveData(p->waveHandle); 
    1019                         SetNaN64(&p->result); 
    1020                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    1021                 case NT_FP64: 
    1022                         dp= WaveData(p->waveHandle); 
     1018                        fp= (float*)WaveData(p->waveHandle); 
     1019                        SetNaN64(&p->result); 
     1020                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     1021                case NT_FP64: 
     1022                        dp= (double*)WaveData(p->waveHandle); 
    10231023                        p->result = Lamellar_ParaCrystal(dp,q); 
    10241024                        return 0; 
     
    10481048        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    10491049                case NT_FP32: 
    1050                         fp= WaveData(p->waveHandle); 
    1051                         SetNaN64(&p->result); 
    1052                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    1053                 case NT_FP64: 
    1054                         dp= WaveData(p->waveHandle); 
     1050                        fp= (float*)WaveData(p->waveHandle); 
     1051                        SetNaN64(&p->result); 
     1052                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     1053                case NT_FP64: 
     1054                        dp= (double*)WaveData(p->waveHandle); 
    10551055                        p->result = PolyCoreBicelle(dp,q); 
    10561056                        return 0; 
     
    10771077        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    10781078                case NT_FP32: 
    1079                         fp= WaveData(p->waveHandle); 
    1080                         SetNaN64(&p->result); 
    1081                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    1082                 case NT_FP64: 
    1083                         dp= WaveData(p->waveHandle); 
     1079                        fp= (float*)WaveData(p->waveHandle); 
     1080                        SetNaN64(&p->result); 
     1081                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     1082                case NT_FP64: 
     1083                        dp= (double*)WaveData(p->waveHandle); 
    10841084                        p->result = CSParallelepiped(dp,q); 
    10851085                        return 0; 
Note: See TracChangeset for help on using the changeset viewer.