Changeset 834


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.

Location:
sans/XOP_Dev
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • sans/XOP_Dev/MonteCarlo/DebyeSpheres.c

    r815 r834  
    1010 
    1111// Prototypes 
    12 HOST_IMPORT void main(IORecHandle ioRecHandle); 
     12HOST_IMPORT int main(IORecHandle ioRecHandle); 
    1313 
    1414// Custom error codes 
    15 #define REQUIRES_IGOR_200 1 + FIRST_XOP_ERR 
     15//#define REQUIRES_IGOR_200 1 + FIRST_XOP_ERR 
    1616#define NON_EXISTENT_WAVE 2 + FIRST_XOP_ERR 
    1717#define REQUIRES_SP_OR_DP_WAVE 3 + FIRST_XOP_ERR 
     
    107107// 
    108108    npt = (int) WavePoints(p->xwavH);   //wavePoints returns long, number of XYZ points 
    109         xv = WaveData(p->xwavH);                //xyz locations 
    110         yv = WaveData(p->ywavH); 
    111         zv = WaveData(p->zwavH); 
    112         rv = WaveData(p->rhowavH); 
     109        xv = (double*)WaveData(p->xwavH);               //xyz locations 
     110        yv = (double*)WaveData(p->ywavH); 
     111        zv = (double*)WaveData(p->zwavH); 
     112        rv = (double*)WaveData(p->rhowavH); 
    113113     
    114114         
     
    204204        // 
    205205    npt = (int) WavePoints(p->xwavH);   //wavePoints returns long, number of XYZ points 
    206         xv = WaveData(p->xwavH);                //xyz locations 
    207         yv = WaveData(p->ywavH); 
    208         zv = WaveData(p->zwavH); 
     206        xv = (double*)WaveData(p->xwavH);               //xyz locations 
     207        yv = (double*)WaveData(p->ywavH); 
     208        zv = (double*)WaveData(p->zwavH); 
    209209         
    210210        p1 = (int) p->p1; 
     
    290290         
    291291         
    292         xv = WaveData(p->xwavH);                //xyz locations 
    293         yv = WaveData(p->ywavH); 
    294         zv = WaveData(p->zwavH); 
    295         bv = WaveData(p->bwavH); 
     292        xv = (double*)WaveData(p->xwavH);               //xyz locations 
     293        yv = (double*)WaveData(p->ywavH); 
     294        zv = (double*)WaveData(p->zwavH); 
     295        bv = (double*)WaveData(p->bwavH); 
    296296         
    297297        grid = p->grid; 
     
    420420    numBins = (int) WavePoints(p->bwavH);       //wavePoints returns long, number of points in bin wave 
    421421         
    422         xv = WaveData(p->xwavH);                //xyz locations 
    423         yv = WaveData(p->ywavH); 
    424         zv = WaveData(p->zwavH); 
    425         rho = WaveData(p->rhowavH); 
    426         SLDLook = WaveData(p->SLDLookH); 
    427         PSFid = WaveData(p->PSFidH);                    //this one is 2D 
     422        xv = (double*)WaveData(p->xwavH);               //xyz locations 
     423        yv = (double*)WaveData(p->ywavH); 
     424        zv = (double*)WaveData(p->zwavH); 
     425        rho = (double*)WaveData(p->rhowavH); 
     426        SLDLook = (double*)WaveData(p->SLDLookH); 
     427        PSFid = (double*)WaveData(p->PSFidH);                   //this one is 2D 
    428428         
    429429        p1 = (int) p->p1; 
     
    517517        return kExpectedNT_FP64; 
    518518    } 
    519         x = WaveData(p->bwavH); 
     519        x = (double*)WaveData(p->bwavH); 
    520520        n = (int)(p->nIn);                      // not sure that the negative input will be properly cast to int 
    521521         
  • sans/XOP_Dev/MonteCarlo/DebyeSpheres.h

    r815 r834  
    1010 
    1111// All structures passed to Igor are two-byte aligned. 
    12 #include "XOPStructureAlignmentTwoByte.h" 
     12#pragma pack(2) 
    1313 
    1414// Parameters passed from Igor to the function, in reverse order of the parameter list 
     
    8585 
    8686 
    87 #include "XOPStructureAlignmentReset.h" 
     87#pragma pack()          // return to default structure packing 
    8888 
    8989 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.c

    r825 r834  
    5757        waveHndl wavH; 
    5858//      int waveType,hState; 
    59         long numDimensions; 
    60         long dimensionSizes[MAX_DIMENSIONS+1]; 
     59        //changed for TK6 
     60        int numDimensions; 
     61        CountInt dimensionSizes[MAX_DIMENSIONS+1]; 
    6162//      char* dataStartPtr; 
    6263//      long dataOffset; 
     
    109110        p->retVal = 0.0; 
    110111         
    111 // trusting that all inputs are DOUBLE PRECISION WAVES!!! 
    112         inputWave = WaveData(p->inputWaveH); 
    113         ran_dev = WaveData(p->ran_devH); 
    114         nt = WaveData(p->ntH); 
    115         j1 = WaveData(p->j1H); 
    116         j2 = WaveData(p->j2H); 
    117         nn = WaveData(p->nnH); 
    118 //      MC_linear_data = WaveData(p->MC_linear_dataH); 
    119         results = WaveData(p->resultsH); 
     112// trusting that all inputs are double PRECISION WAVES!!! 
     113        inputWave = (double*)WaveData(p->inputWaveH); 
     114        ran_dev = (double*)WaveData(p->ran_devH); 
     115        nt = (double*)WaveData(p->ntH); 
     116        j1 = (double*)WaveData(p->j1H); 
     117        j2 = (double*)WaveData(p->j2H); 
     118        nn = (double*)WaveData(p->nnH); 
     119//      MC_linear_data = (double*)WaveData(p->MC_linear_dataH); 
     120        results = (double*)WaveData(p->resultsH); 
    120121         
    121122        seed = (long)results[0]; 
     
    160161        if (wavH == NIL) 
    161162                return NOWAV; 
    162  
    163 //      waveType = WaveType(wavH); 
    164 //      if (waveType & NT_CMPLX) 
    165 //              return NO_COMPLEX_WAVE; 
    166 //      if (waveType==TEXT_WAVE_TYPE) 
    167 //              return NUMERIC_ACCESS_ON_TEXT_WAVE; 
    168 //      if (retVal = MDGetWaveDimensions(wavH, &numDimensions, dimensionSizes)) 
    169 //              return retVal; 
    170 //      numRows = dimensionSizes[0]; 
    171 //      numColumns = dimensionSizes[1]; 
    172          
    173 //      if (retVal = MDAccessNumericWaveData(wavH, kMDWaveAccessMode0, &dataOffset)) 
    174 //              return retVal; 
    175                  
    176 //      hState = MoveLockHandle(wavH);          // So wave data can't move. Remember to call HSetState when done. 
    177 //      dataStartPtr = (char*)(*wavH) + dataOffset; 
    178 //      dp0 = (double*)dataStartPtr;                    // Pointer to the start of the 2D wave data. 
    179163         
    180164//scattering power and maximum qvalue to bin 
     
    502486 
    503487 
    504 //      HSetState((Handle)wavH, hState);                //release the handle of the 2D data wave 
    505488//      WaveHandleModified(wavH);                       // Inform Igor that we have changed the wave. (CALLBACK! needed, but not allowed in Threading) 
    506489         
  • sans/XOP_Dev/MonteCarlo/MonteCarlo.h

    r812 r834  
    2020  
    2121/* Prototypes */ 
    22 HOST_IMPORT void main(IORecHandle ioRecHandle); 
     22// for TK6 
     23HOST_IMPORT int main(IORecHandle ioRecHandle); 
    2324 
    2425  
    25 #define OLD_IGOR 1 + FIRST_XOP_ERR 
     26//#define OLD_IGOR 1 + FIRST_XOP_ERR 
    2627#define NON_EXISTENT_WAVE 2 + FIRST_XOP_ERR 
    2728#define NEEDS_2D_WAVE 3 + FIRST_XOP_ERR 
     
    2930 
    3031// All structures passed to Igor are two-byte aligned. 
    31 #include "XOPStructureAlignmentTwoByte.h" 
     32#pragma pack(2) 
    3233 
    3334struct MC_Params {     // This structure must be 2-byte-aligned because it receives parameters from Igor. 
     
    4647typedef struct MC_Params *MC_ParamsPtr; 
    4748 
    48 #include "XOPStructureAlignmentReset.h" 
    49  
     49#pragma pack()          // return to default structure packing 
    5050 
    5151// function prototypes 
  • sans/XOP_Dev/MonteCarlo/MonteCarlo2.c

    r825 r834  
    6060        waveHndl wavH; 
    6161//      int waveType,hState; 
    62         long numDimensions; 
    63         long dimensionSizes[MAX_DIMENSIONS+1]; 
     62        //changed for TK6 
     63        int numDimensions; 
     64        CountInt dimensionSizes[MAX_DIMENSIONS+1]; 
    6465//      char* dataStartPtr; 
    6566//      long dataOffset; 
     
    112113        p->retVal = 0; 
    113114         
    114 // trusting that all inputs are DOUBLE PRECISION WAVES!!! 
    115         inputWave = WaveData(p->inputWaveH); 
    116         ran_dev = WaveData(p->ran_devH); 
    117         nt = WaveData(p->ntH); 
    118         j1 = WaveData(p->j1H); 
    119         j2 = WaveData(p->j2H); 
    120         nn = WaveData(p->nnH); 
    121 //      MC_linear_data = WaveData(p->MC_linear_dataH); 
    122         results = WaveData(p->resultsH); 
     115// trusting that all inputs are double PRECISION WAVES!!! 
     116        inputWave = (double*)WaveData(p->inputWaveH); 
     117        ran_dev = (double*)WaveData(p->ran_devH); 
     118        nt = (double*)WaveData(p->ntH); 
     119        j1 = (double*)WaveData(p->j1H); 
     120        j2 = (double*)WaveData(p->j2H); 
     121        nn = (double*)WaveData(p->nnH); 
     122//      MC_linear_data = (double*)WaveData(p->MC_linear_dataH); 
     123        results = (double*)WaveData(p->resultsH); 
    123124         
    124125        seed = (long)results[0]; 
     
    164165                return NOWAV; 
    165166 
    166 //      waveType = WaveType(wavH); 
    167 //      if (waveType & NT_CMPLX) 
    168 //              return NO_COMPLEX_WAVE; 
    169 //      if (waveType==TEXT_WAVE_TYPE) 
    170 //              return NUMERIC_ACCESS_ON_TEXT_WAVE; 
    171 //      if (retVal = MDGetWaveDimensions(wavH, &numDimensions, dimensionSizes)) 
    172 //              return retVal; 
    173 //      numRows = dimensionSizes[0]; 
    174 //      numColumns = dimensionSizes[1]; 
    175          
    176 //      if (retVal = MDAccessNumericWaveData(wavH, kMDWaveAccessMode0, &dataOffset)) 
    177 //              return retVal; 
    178                  
    179 //      hState = MoveLockHandle(wavH);          // So wave data can't move. Remember to call HSetState when done. 
    180 //      dataStartPtr = (char*)(*wavH) + dataOffset; 
    181 //      dp0 = (double*)dataStartPtr;                    // Pointer to the start of the 2D wave data. 
    182167         
    183168//scattering power and maximum qvalue to bin 
     
    502487                return retVal; 
    503488 
    504 //      HSetState((Handle)wavH, hState);                //release the handle of the 2D data wave 
    505489//      WaveHandleModified(wavH);                       // Inform Igor that we have changed the wave. (CALLBACK! needed, but not allowed in Threading) 
    506490         
  • sans/XOP_Dev/MonteCarlo/MonteCarlo3.c

    r825 r834  
    5858        waveHndl wavH; 
    5959        //      int waveType,hState; 
    60         long numDimensions; 
    61         long dimensionSizes[MAX_DIMENSIONS+1]; 
     60        //changed for TK6 
     61        int numDimensions; 
     62        CountInt dimensionSizes[MAX_DIMENSIONS+1]; 
    6263        //      char* dataStartPtr; 
    6364        //      long dataOffset; 
     
    110111        p->retVal = 0; 
    111112         
    112         // trusting that all inputs are DOUBLE PRECISION WAVES!!! 
    113         inputWave = WaveData(p->inputWaveH); 
    114         ran_dev = WaveData(p->ran_devH); 
    115         nt = WaveData(p->ntH); 
    116         j1 = WaveData(p->j1H); 
    117         j2 = WaveData(p->j2H); 
    118         nn = WaveData(p->nnH); 
    119         //      MC_linear_data = WaveData(p->MC_linear_dataH); 
    120         results = WaveData(p->resultsH); 
     113        // trusting that all inputs are double PRECISION WAVES!!! 
     114        inputWave = (double*)WaveData(p->inputWaveH); 
     115        ran_dev = (double*)WaveData(p->ran_devH); 
     116        nt = (double*)WaveData(p->ntH); 
     117        j1 = (double*)WaveData(p->j1H); 
     118        j2 = (double*)WaveData(p->j2H); 
     119        nn = (double*)WaveData(p->nnH); 
     120        //      MC_linear_data = (double*)WaveData(p->MC_linear_dataH); 
     121        results = (double*)WaveData(p->resultsH); 
    121122         
    122123        seed = (long)results[0]; 
     
    162163                return NOWAV; 
    163164         
    164         //      waveType = WaveType(wavH); 
    165         //      if (waveType & NT_CMPLX) 
    166         //              return NO_COMPLEX_WAVE; 
    167         //      if (waveType==TEXT_WAVE_TYPE) 
    168         //              return NUMERIC_ACCESS_ON_TEXT_WAVE; 
    169         //      if (retVal = MDGetWaveDimensions(wavH, &numDimensions, dimensionSizes)) 
    170         //              return retVal; 
    171         //      numRows = dimensionSizes[0]; 
    172         //      numColumns = dimensionSizes[1]; 
    173          
    174         //      if (retVal = MDAccessNumericWaveData(wavH, kMDWaveAccessMode0, &dataOffset)) 
    175         //              return retVal; 
    176          
    177         //      hState = MoveLockHandle(wavH);          // So wave data can't move. Remember to call HSetState when done. 
    178         //      dataStartPtr = (char*)(*wavH) + dataOffset; 
    179         //      dp0 = (double*)dataStartPtr;                    // Pointer to the start of the 2D wave data. 
    180165         
    181166        //scattering power and maximum qvalue to bin 
     
    498483                return retVal; 
    499484         
    500         //      HSetState((Handle)wavH, hState);                //release the handle of the 2D data wave 
    501485        //      WaveHandleModified(wavH);                       // Inform Igor that we have changed the wave. (CALLBACK! needed, but not allowed in Threading) 
    502486         
  • sans/XOP_Dev/MonteCarlo/MonteCarlo4.c

    r825 r834  
    5959        waveHndl wavH; 
    6060        //      int waveType,hState; 
    61         long numDimensions; 
    62         long dimensionSizes[MAX_DIMENSIONS+1]; 
     61        //changed for TK6 
     62        int numDimensions; 
     63        CountInt dimensionSizes[MAX_DIMENSIONS+1]; 
    6364        //      char* dataStartPtr; 
    6465        //      long dataOffset; 
     
    111112        p->retVal = 0; 
    112113         
    113         // trusting that all inputs are DOUBLE PRECISION WAVES!!! 
    114         inputWave = WaveData(p->inputWaveH); 
    115         ran_dev = WaveData(p->ran_devH); 
    116         nt = WaveData(p->ntH); 
    117         j1 = WaveData(p->j1H); 
    118         j2 = WaveData(p->j2H); 
    119         nn = WaveData(p->nnH); 
    120         //      MC_linear_data = WaveData(p->MC_linear_dataH); 
    121         results = WaveData(p->resultsH); 
     114        // trusting that all inputs are double PRECISION WAVES!!! 
     115        inputWave = (double*)WaveData(p->inputWaveH); 
     116        ran_dev = (double*)WaveData(p->ran_devH); 
     117        nt = (double*)WaveData(p->ntH); 
     118        j1 = (double*)WaveData(p->j1H); 
     119        j2 = (double*)WaveData(p->j2H); 
     120        nn = (double*)WaveData(p->nnH); 
     121        //      MC_linear_data = (double*)WaveData(p->MC_linear_dataH); 
     122        results = (double*)WaveData(p->resultsH); 
    122123         
    123124        seed = (long)results[0]; 
     
    163164                return NOWAV; 
    164165         
    165         //      waveType = WaveType(wavH); 
    166         //      if (waveType & NT_CMPLX) 
    167         //              return NO_COMPLEX_WAVE; 
    168         //      if (waveType==TEXT_WAVE_TYPE) 
    169         //              return NUMERIC_ACCESS_ON_TEXT_WAVE; 
    170         //      if (retVal = MDGetWaveDimensions(wavH, &numDimensions, dimensionSizes)) 
    171         //              return retVal; 
    172         //      numRows = dimensionSizes[0]; 
    173         //      numColumns = dimensionSizes[1]; 
    174          
    175         //      if (retVal = MDAccessNumericWaveData(wavH, kMDWaveAccessMode0, &dataOffset)) 
    176         //              return retVal; 
    177          
    178         //      hState = MoveLockHandle(wavH);          // So wave data can't move. Remember to call HSetState when done. 
    179         //      dataStartPtr = (char*)(*wavH) + dataOffset; 
    180         //      dp0 = (double*)dataStartPtr;                    // Pointer to the start of the 2D wave data. 
    181166         
    182167        //scattering power and maximum qvalue to bin 
     
    499484                return retVal; 
    500485         
    501         //      HSetState((Handle)wavH, hState);                //release the handle of the 2D data wave 
    502486        //      WaveHandleModified(wavH);                       // Inform Igor that we have changed the wave. (CALLBACK! needed, but not allowed in Threading) 
    503487         
  • sans/XOP_Dev/MonteCarlo/MonteCarlo_Main.c

    r812 r834  
    415415 main() does any necessary initialization and then sets the XOPEntry field of the 
    416416 ioRecHandle to the address to be called for future messages. 
     417  
     418 changed for TK6 30JAN2012 SRK 
    417419 */ 
    418 HOST_IMPORT void 
     420HOST_IMPORT int 
    419421main(IORecHandle ioRecHandle) 
    420422{        
     
    422424        SetXOPEntry(XOPEntry);                                                  // Set entry point for future calls. 
    423425         
    424         if (igorVersion < 600)                          // Requires Igor Pro 6.00 or later. 
    425                 SetXOPResult(OLD_IGOR);                 // OLD_IGOR is defined in WaveAccess.h and there are corresponding error strings in WaveAccess.r and WaveAccessWinCustom.rc. 
    426         else 
    427                 SetXOPResult(0L); 
    428 } 
     426        if (igorVersion < 600)  {                                       // Requires Igor Pro 6.00 or later. 
     427                SetXOPResult(IGOR_OBSOLETE);     
     428                return EXIT_FAILURE; 
     429        } 
     430 
     431        SetXOPResult(0); 
     432        return EXIT_SUCCESS; 
     433         
     434} 
  • 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; 
  • sans/XOP_Dev/SANSAnalysis/XOP/Func2D.c

    r235 r834  
    4646        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    4747                case NT_FP32: 
    48                         fp= WaveData(p->waveHandle); 
    49             SetNaN64(&p->result); 
    50                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    51                 case NT_FP64: 
    52                         dp= WaveData(p->waveHandle); 
     48                        fp= (float*)WaveData(p->waveHandle); 
     49            SetNaN64(&p->result); 
     50                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     51                case NT_FP64: 
     52                        dp= (double*)WaveData(p->waveHandle); 
    5353                         
    5454//                      for(i=0; i<11; i++) { 
     
    106106        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    107107                case NT_FP32: 
    108                         fp= WaveData(p->waveHandle); 
    109             SetNaN64(&p->result); 
    110                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    111                 case NT_FP64: 
    112                         dp= WaveData(p->waveHandle); 
    113                         par_values = WaveData(p->par_values); 
    114                         weight_values = WaveData(p->weight_values); 
     108                        fp= (float*)WaveData(p->waveHandle); 
     109            SetNaN64(&p->result); 
     110                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     111                case NT_FP64: 
     112                        dp= (double*)WaveData(p->waveHandle); 
     113                        par_values = (double*)WaveData(p->par_values); 
     114                        weight_values = (double*)WaveData(p->weight_values); 
    115115                         
    116116                        for(i=0; i<13; i++) { 
     
    186186        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    187187                case NT_FP32: 
    188                         fp= WaveData(p->waveHandle); 
    189             SetNaN64(&p->result); 
    190                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    191                 case NT_FP64: 
    192                         dp= WaveData(p->waveHandle); 
     188                        fp= (float*)WaveData(p->waveHandle); 
     189            SetNaN64(&p->result); 
     190                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     191                case NT_FP64: 
     192                        dp= (double*)WaveData(p->waveHandle); 
    193193                         
    194194                        for(i=0; i<15; i++) { 
     
    235235        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    236236                case NT_FP32: 
    237                         fp= WaveData(p->waveHandle); 
    238             SetNaN64(&p->result); 
    239                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    240                 case NT_FP64: 
    241                         dp= WaveData(p->waveHandle); 
    242                         par_values = WaveData(p->par_values); 
    243                         weight_values = WaveData(p->weight_values); 
     237                        fp= (float*)WaveData(p->waveHandle); 
     238            SetNaN64(&p->result); 
     239                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     240                case NT_FP64: 
     241                        dp= (double*)WaveData(p->waveHandle); 
     242                        par_values = (double*)WaveData(p->par_values); 
     243                        weight_values = (double*)WaveData(p->weight_values); 
    244244                         
    245245                        for(i=0; i<17; i++) { 
     
    314314        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    315315                case NT_FP32: 
    316                         fp= WaveData(p->waveHandle); 
    317             SetNaN64(&p->result); 
    318                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    319                 case NT_FP64: 
    320                         dp= WaveData(p->waveHandle); 
     316                        fp= (float*)WaveData(p->waveHandle); 
     317            SetNaN64(&p->result); 
     318                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     319                case NT_FP64: 
     320                        dp= (double*)WaveData(p->waveHandle); 
    321321                         
    322322//                      for(i=0; i<12; i++) { 
     
    376376        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    377377                case NT_FP32: 
    378                         fp= WaveData(p->waveHandle); 
    379             SetNaN64(&p->result); 
    380                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    381                 case NT_FP64: 
    382                         dp= WaveData(p->waveHandle); 
    383                         par_values = WaveData(p->par_values); 
    384                         weight_values = WaveData(p->weight_values); 
     378                        fp= (float*)WaveData(p->waveHandle); 
     379            SetNaN64(&p->result); 
     380                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     381                case NT_FP64: 
     382                        dp= (double*)WaveData(p->waveHandle); 
     383                        par_values = (double*)WaveData(p->par_values); 
     384                        weight_values = (double*)WaveData(p->weight_values); 
    385385                         
    386386                        for(i=0; i<14; i++) { 
     
    455455        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    456456                case NT_FP32: 
    457                         fp= WaveData(p->waveHandle); 
    458             SetNaN64(&p->result); 
    459                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    460                 case NT_FP64: 
    461                         dp= WaveData(p->waveHandle); 
     457                        fp= (float*)WaveData(p->waveHandle); 
     458            SetNaN64(&p->result); 
     459                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     460                case NT_FP64: 
     461                        dp= (double*)WaveData(p->waveHandle); 
    462462                         
    463463//                      for(i=0; i<14; i++) { 
     
    520520        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    521521                case NT_FP32: 
    522                         fp= WaveData(p->waveHandle); 
    523             SetNaN64(&p->result); 
    524                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    525                 case NT_FP64: 
    526                         dp= WaveData(p->waveHandle); 
    527                         par_values = WaveData(p->par_values); 
    528                         weight_values = WaveData(p->weight_values); 
     522                        fp= (float*)WaveData(p->waveHandle); 
     523            SetNaN64(&p->result); 
     524                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     525                case NT_FP64: 
     526                        dp= (double*)WaveData(p->waveHandle); 
     527                        par_values = (double*)WaveData(p->par_values); 
     528                        weight_values = (double*)WaveData(p->weight_values); 
    529529                         
    530530                        for(i=0; i<16; i++) { 
     
    607607        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    608608                case NT_FP32: 
    609                         fp= WaveData(p->waveHandle); 
    610             SetNaN64(&p->result); 
    611                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    612                 case NT_FP64: 
    613                         dp= WaveData(p->waveHandle); 
     609                        fp= (float*)WaveData(p->waveHandle); 
     610            SetNaN64(&p->result); 
     611                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
     612                case NT_FP64: 
     613                        dp= (double*)WaveData(p->waveHandle); 
    614614                         
    615615                        for(i=0; i<5; i++) { 
  • sans/XOP_Dev/SANSAnalysis/XOP/ResolutionSmearing.c

    r245 r834  
    332332        i_sigq = p->i_sigq; 
    333333         
    334         dp = WaveData(p->waveHandle); 
     334        dp = (double*)WaveData(p->waveHandle); 
    335335        q = p->x; 
    336336         
  • sans/XOP_Dev/SANSAnalysis/XOP/ResolutionSmearing.h

    r188 r834  
    33*/ 
    44 
    5 #include "XOPStructureAlignmentTwoByte.h" 
     5#pragma pack(2) 
    66 
    77/* Prototypes */ 
     
    3030}PassParams, *PassParamsPtr; 
    3131 
    32 #include "XOPStructureAlignmentReset.h" 
     32#pragma pack() 
    3333 
    3434/* IGOR Fit Functions */ 
  • sans/XOP_Dev/SANSAnalysis/XOP/SANSAnalysis.c

    r756 r834  
    362362main() does any necessary initialization and then sets the XOPEntry field of the 
    363363ioRecHandle to the address to be called for future messages. 
     364  
     365 updated for TK6 30JAN2012 SRK 
    364366*/ 
    365 HOST_IMPORT void 
     367HOST_IMPORT int                                         // was void 
    366368main(IORecHandle ioRecHandle) 
    367369{        
     
    371373        if (igorVersion < 600) {                                                // checks required for ThreadSafe declarations 
    372374                SetXOPResult(IGOR_OBSOLETE); 
     375                return EXIT_FAILURE;                                    // added for TK6 
    373376        } 
    374         else { 
    375                 if (igorVersion >= 700) 
    376                         SetXOPResult(IGOR_OBSOLETE); 
    377                 else 
    378                         SetXOPResult(0L); 
    379         } 
     377         
     378        SetXOPResult(0); 
     379        return EXIT_SUCCESS;                                    // added for TK6 
     380         
     381//      else { 
     382//              if (igorVersion >= 700) 
     383//                      SetXOPResult(IGOR_OBSOLETE); 
     384//              else 
     385//                      SetXOPResult(0L); 
     386//      } 
     387         
    380388} 
    381389 
  • sans/XOP_Dev/SANSAnalysis/XOP/SANSAnalysis.h

    r231 r834  
    55 
    66/* Prototypes */ 
    7 HOST_IMPORT void main(IORecHandle ioRecHandle); 
     7// for TK6 
     8HOST_IMPORT int main(IORecHandle ioRecHandle); 
    89 
    910// Custom error codes 
    10 #define REQUIRES_IGOR_200 1 + FIRST_XOP_ERR 
     11//#define REQUIRES_IGOR_200 1 + FIRST_XOP_ERR 
    1112#define NON_EXISTENT_WAVE 2 + FIRST_XOP_ERR 
    1213#define REQUIRES_SP_OR_DP_WAVE 3 + FIRST_XOP_ERR 
    1314 
    1415 
    15 #include "XOPStructureAlignmentTwoByte.h" 
     16#pragma pack(2) 
    1617 
    1718// Fit function parameter structure 
     
    4344}FitParams2DWeight, *FitParams2DWeightPtr; 
    4445 
    45 #include "XOPStructureAlignmentReset.h" 
     46#pragma pack() 
     47 
  • sans/XOP_Dev/SANSAnalysis/XOP/Sphere.c

    r592 r834  
    3030        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    3131                case NT_FP32: 
    32                         fp= WaveData(p->waveHandle); 
    33                         SetNaN64(&p->result); 
    34                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    35                 case NT_FP64: 
    36                         dp= WaveData(p->waveHandle); 
     32                        fp= (float*)WaveData(p->waveHandle); 
     33                        SetNaN64(&p->result); 
     34                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     35                case NT_FP64: 
     36                        dp= (double*)WaveData(p->waveHandle); 
    3737                        p->result = SphereForm(dp,q); 
    3838                        return 0; 
     
    6262        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    6363                case NT_FP32: 
    64                         fp= WaveData(p->waveHandle); 
    65                         SetNaN64(&p->result); 
    66                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    67                 case NT_FP64: 
    68                         dp= WaveData(p->waveHandle); 
     64                        fp= (float*)WaveData(p->waveHandle); 
     65                        SetNaN64(&p->result); 
     66                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     67                case NT_FP64: 
     68                        dp= (double*)WaveData(p->waveHandle); 
    6969                        p->result = CoreShellForm(dp,q); 
    7070                        return 0; 
     
    9494        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    9595                case NT_FP32: 
    96                         fp= WaveData(p->waveHandle); 
    97                         SetNaN64(&p->result); 
    98                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    99                 case NT_FP64: 
    100                         dp= WaveData(p->waveHandle); 
     96                        fp= (float*)WaveData(p->waveHandle); 
     97                        SetNaN64(&p->result); 
     98                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     99                case NT_FP64: 
     100                        dp= (double*)WaveData(p->waveHandle); 
    101101                        p->result = VesicleForm(dp,q); 
    102102                        return 0; 
     
    127127        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    128128                case NT_FP32: 
    129                         fp= WaveData(p->waveHandle); 
    130                         SetNaN64(&p->result); 
    131                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    132                 case NT_FP64: 
    133                         dp= WaveData(p->waveHandle); 
     129                        fp= (float*)WaveData(p->waveHandle); 
     130                        SetNaN64(&p->result); 
     131                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     132                case NT_FP64: 
     133                        dp= (double*)WaveData(p->waveHandle); 
    134134                        p->result = PolyCoreForm(dp,q); 
    135135                        return 0; 
     
    161161        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    162162                case NT_FP32: 
    163                         fp= WaveData(p->waveHandle); 
    164                         SetNaN64(&p->result); 
    165                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    166                 case NT_FP64: 
    167                         dp= WaveData(p->waveHandle); 
     163                        fp= (float*)WaveData(p->waveHandle); 
     164                        SetNaN64(&p->result); 
     165                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     166                case NT_FP64: 
     167                        dp= (double*)WaveData(p->waveHandle); 
    168168                        p->result = PolyHardSphereIntensity(dp,q); 
    169169                        return 0; 
     
    194194        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    195195                case NT_FP32: 
    196                         fp= WaveData(p->waveHandle); 
    197                         SetNaN64(&p->result); 
    198                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    199                 case NT_FP64: 
    200                         dp= WaveData(p->waveHandle); 
     196                        fp= (float*)WaveData(p->waveHandle); 
     197                        SetNaN64(&p->result); 
     198                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     199                case NT_FP64: 
     200                        dp= (double*)WaveData(p->waveHandle); 
    201201                        p->result = BimodalSchulzSpheres(dp,q); 
    202202                        return 0; 
     
    227227        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    228228                case NT_FP32: 
    229                         fp= WaveData(p->waveHandle); 
    230                         SetNaN64(&p->result); 
    231                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    232                 case NT_FP64: 
    233                         dp= WaveData(p->waveHandle); 
     229                        fp= (float*)WaveData(p->waveHandle); 
     230                        SetNaN64(&p->result); 
     231                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     232                case NT_FP64: 
     233                        dp= (double*)WaveData(p->waveHandle); 
    234234                        p->result = SchulzSpheres(dp,q); 
    235235                        return 0; 
     
    261261        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    262262                case NT_FP32: 
    263                         fp= WaveData(p->waveHandle); 
    264                         SetNaN64(&p->result); 
    265                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    266                 case NT_FP64: 
    267                         dp= WaveData(p->waveHandle); 
     263                        fp= (float*)WaveData(p->waveHandle); 
     264                        SetNaN64(&p->result); 
     265                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     266                case NT_FP64: 
     267                        dp= (double*)WaveData(p->waveHandle); 
    268268                        p->result = PolyRectSpheres(dp,q); 
    269269                        return 0; 
     
    294294        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    295295                case NT_FP32: 
    296                         fp= WaveData(p->waveHandle); 
    297                         SetNaN64(&p->result); 
    298                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    299                 case NT_FP64: 
    300                         dp= WaveData(p->waveHandle); 
     296                        fp= (float*)WaveData(p->waveHandle); 
     297                        SetNaN64(&p->result); 
     298                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     299                case NT_FP64: 
     300                        dp= (double*)WaveData(p->waveHandle); 
    301301                        p->result = GaussPolySphere(dp,q); 
    302302                        return 0; 
     
    327327        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    328328                case NT_FP32: 
    329                         fp= WaveData(p->waveHandle); 
    330                         SetNaN64(&p->result); 
    331                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    332                 case NT_FP64: 
    333                         dp= WaveData(p->waveHandle); 
     329                        fp= (float*)WaveData(p->waveHandle); 
     330                        SetNaN64(&p->result); 
     331                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     332                case NT_FP64: 
     333                        dp= (double*)WaveData(p->waveHandle); 
    334334                        p->result = LogNormalPolySphere(dp,q); 
    335335                        return 0; 
     
    361361        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    362362                case NT_FP32: 
    363                         fp= WaveData(p->waveHandle); 
    364                         SetNaN64(&p->result); 
    365                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    366                 case NT_FP64: 
    367                         dp= WaveData(p->waveHandle); 
     363                        fp= (float*)WaveData(p->waveHandle); 
     364                        SetNaN64(&p->result); 
     365                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     366                case NT_FP64: 
     367                        dp= (double*)WaveData(p->waveHandle); 
    368368                        p->result = PolyCoreShellRatio(dp,q); 
    369369                        return 0; 
     
    404404        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    405405                case NT_FP32: 
    406                         fp= WaveData(p->waveHandle); 
    407                         SetNaN64(&p->result); 
    408                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    409                 case NT_FP64: 
    410                         dp= WaveData(p->waveHandle); 
     406                        fp= (float*)WaveData(p->waveHandle); 
     407                        SetNaN64(&p->result); 
     408                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     409                case NT_FP64: 
     410                        dp= (double*)WaveData(p->waveHandle); 
    411411                        p->result = BinaryHS(dp,q); 
    412412                        return 0; 
     
    434434        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    435435                case NT_FP32: 
    436                         fp= WaveData(p->waveHandle); 
    437                         SetNaN64(&p->result); 
    438                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    439                 case NT_FP64: 
    440                         dp= WaveData(p->waveHandle); 
     436                        fp= (float*)WaveData(p->waveHandle); 
     437                        SetNaN64(&p->result); 
     438                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     439                case NT_FP64: 
     440                        dp= (double*)WaveData(p->waveHandle); 
    441441                        p->result = BinaryHS_PSF11(dp,q); 
    442442                        return 0; 
     
    464464        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    465465                case NT_FP32: 
    466                         fp= WaveData(p->waveHandle); 
    467                         SetNaN64(&p->result); 
    468                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    469                 case NT_FP64: 
    470                         dp= WaveData(p->waveHandle); 
     466                        fp= (float*)WaveData(p->waveHandle); 
     467                        SetNaN64(&p->result); 
     468                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     469                case NT_FP64: 
     470                        dp= (double*)WaveData(p->waveHandle); 
    471471                        p->result = BinaryHS_PSF12(dp,q); 
    472472                        return 0; 
     
    495495        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    496496                case NT_FP32: 
    497                         fp= WaveData(p->waveHandle); 
    498                         SetNaN64(&p->result); 
    499                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    500                 case NT_FP64: 
    501                         dp= WaveData(p->waveHandle); 
     497                        fp= (float*)WaveData(p->waveHandle); 
     498                        SetNaN64(&p->result); 
     499                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     500                case NT_FP64: 
     501                        dp= (double*)WaveData(p->waveHandle); 
    502502                        p->result = BinaryHS_PSF22(dp,q); 
    503503                        return 0; 
     
    520520  
    521521        Warning: 
    522  The call to WaveData() below returns a pointer to the middle 
     522 The call to (float*)WaveData() below returns a pointer to the middle 
    523523 of an unlocked Macintosh handle. In the unlikely event that your 
    524524 calculations could cause memory to move, you should copy the coefficient 
     
    541541        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    542542                case NT_FP32: 
    543                         fp= WaveData(p->waveHandle); 
    544                         SetNaN64(&p->result); 
    545                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    546                 case NT_FP64: 
    547                         dp= WaveData(p->waveHandle); 
     543                        fp= (float*)WaveData(p->waveHandle); 
     544                        SetNaN64(&p->result); 
     545                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     546                case NT_FP64: 
     547                        dp= (double*)WaveData(p->waveHandle); 
    548548                        p->result = MultiShell(dp,q); 
    549549                        return 0; 
     
    568568 // 
    569569        Warning: 
    570  The call to WaveData() below returns a pointer to the middle 
     570 The call to (float*)WaveData() below returns a pointer to the middle 
    571571 of an unlocked Macintosh handle. In the unlikely event that your 
    572572 calculations could cause memory to move, you should copy the coefficient 
     
    589589        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    590590                case NT_FP32: 
    591                         fp= WaveData(p->waveHandle); 
    592                         SetNaN64(&p->result); 
    593                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    594                 case NT_FP64: 
    595                         dp= WaveData(p->waveHandle); 
     591                        fp= (float*)WaveData(p->waveHandle); 
     592                        SetNaN64(&p->result); 
     593                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     594                case NT_FP64: 
     595                        dp= (double*)WaveData(p->waveHandle); 
    596596                        p->result = PolyMultiShell(dp,q); 
    597597                        return 0; 
     
    621621        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    622622                case NT_FP32: 
    623                         fp= WaveData(p->waveHandle); 
    624                         SetNaN64(&p->result); 
    625                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    626                 case NT_FP64: 
    627                         dp= WaveData(p->waveHandle); 
     623                        fp= (float*)WaveData(p->waveHandle); 
     624                        SetNaN64(&p->result); 
     625                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     626                case NT_FP64: 
     627                        dp= (double*)WaveData(p->waveHandle); 
    628628                        p->result = OneShell(dp,q); 
    629629                        return 0; 
     
    651651        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    652652                case NT_FP32: 
    653                         fp= WaveData(p->waveHandle); 
    654                         SetNaN64(&p->result); 
    655                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    656                 case NT_FP64: 
    657                         dp= WaveData(p->waveHandle); 
     653                        fp= (float*)WaveData(p->waveHandle); 
     654                        SetNaN64(&p->result); 
     655                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     656                case NT_FP64: 
     657                        dp= (double*)WaveData(p->waveHandle); 
    658658                        p->result = TwoShell(dp,q); 
    659659                        return 0; 
     
    681681        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    682682                case NT_FP32: 
    683                         fp= WaveData(p->waveHandle); 
    684                         SetNaN64(&p->result); 
    685                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    686                 case NT_FP64: 
    687                         dp= WaveData(p->waveHandle); 
     683                        fp= (float*)WaveData(p->waveHandle); 
     684                        SetNaN64(&p->result); 
     685                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     686                case NT_FP64: 
     687                        dp= (double*)WaveData(p->waveHandle); 
    688688                        p->result = ThreeShell(dp,q); 
    689689                        return 0; 
     
    711711        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    712712                case NT_FP32: 
    713                         fp= WaveData(p->waveHandle); 
    714                         SetNaN64(&p->result); 
    715                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    716                 case NT_FP64: 
    717                         dp= WaveData(p->waveHandle); 
     713                        fp= (float*)WaveData(p->waveHandle); 
     714                        SetNaN64(&p->result); 
     715                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     716                case NT_FP64: 
     717                        dp= (double*)WaveData(p->waveHandle); 
    718718                        p->result = FourShell(dp,q); 
    719719                        return 0; 
     
    743743        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    744744                case NT_FP32: 
    745                         fp= WaveData(p->waveHandle); 
    746                         SetNaN64(&p->result); 
    747                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    748                 case NT_FP64: 
    749                         dp= WaveData(p->waveHandle); 
     745                        fp= (float*)WaveData(p->waveHandle); 
     746                        SetNaN64(&p->result); 
     747                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     748                case NT_FP64: 
     749                        dp= (double*)WaveData(p->waveHandle); 
    750750                        p->result = PolyOneShell(dp,q); 
    751751                        return 0; 
     
    773773        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    774774                case NT_FP32: 
    775                         fp= WaveData(p->waveHandle); 
    776                         SetNaN64(&p->result); 
    777                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    778                 case NT_FP64: 
    779                         dp= WaveData(p->waveHandle); 
     775                        fp= (float*)WaveData(p->waveHandle); 
     776                        SetNaN64(&p->result); 
     777                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     778                case NT_FP64: 
     779                        dp= (double*)WaveData(p->waveHandle); 
    780780                        p->result = PolyTwoShell(dp,q); 
    781781                        return 0; 
     
    803803        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    804804                case NT_FP32: 
    805                         fp= WaveData(p->waveHandle); 
    806                         SetNaN64(&p->result); 
    807                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    808                 case NT_FP64: 
    809                         dp= WaveData(p->waveHandle); 
     805                        fp= (float*)WaveData(p->waveHandle); 
     806                        SetNaN64(&p->result); 
     807                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     808                case NT_FP64: 
     809                        dp= (double*)WaveData(p->waveHandle); 
    810810                        p->result = PolyThreeShell(dp,q); 
    811811                        return 0; 
     
    833833        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    834834                case NT_FP32: 
    835                         fp= WaveData(p->waveHandle); 
    836                         SetNaN64(&p->result); 
    837                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    838                 case NT_FP64: 
    839                         dp= WaveData(p->waveHandle); 
     835                        fp= (float*)WaveData(p->waveHandle); 
     836                        SetNaN64(&p->result); 
     837                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     838                case NT_FP64: 
     839                        dp= (double*)WaveData(p->waveHandle); 
    840840                        p->result = PolyFourShell(dp,q); 
    841841                        return 0; 
     
    864864        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    865865                case NT_FP32: 
    866                         fp= WaveData(p->waveHandle); 
    867                         SetNaN64(&p->result); 
    868                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    869                 case NT_FP64: 
    870                         dp= WaveData(p->waveHandle); 
     866                        fp= (float*)WaveData(p->waveHandle); 
     867                        SetNaN64(&p->result); 
     868                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     869                case NT_FP64: 
     870                        dp= (double*)WaveData(p->waveHandle); 
    871871                        p->result = BCC_ParaCrystal(dp,q); 
    872872                        return 0; 
     
    895895        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    896896                case NT_FP32: 
    897                         fp= WaveData(p->waveHandle); 
    898                         SetNaN64(&p->result); 
    899                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    900                 case NT_FP64: 
    901                         dp= WaveData(p->waveHandle); 
     897                        fp= (float*)WaveData(p->waveHandle); 
     898                        SetNaN64(&p->result); 
     899                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     900                case NT_FP64: 
     901                        dp= (double*)WaveData(p->waveHandle); 
    902902                        p->result = FCC_ParaCrystal(dp,q); 
    903903                        return 0; 
     
    926926        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    927927                case NT_FP32: 
    928                         fp= WaveData(p->waveHandle); 
    929                         SetNaN64(&p->result); 
    930                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    931                 case NT_FP64: 
    932                         dp= WaveData(p->waveHandle); 
     928                        fp= (float*)WaveData(p->waveHandle); 
     929                        SetNaN64(&p->result); 
     930                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     931                case NT_FP64: 
     932                        dp= (double*)WaveData(p->waveHandle); 
    933933                        p->result = SC_ParaCrystal(dp,q); 
    934934                        return 0; 
     
    956956        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    957957                case NT_FP32: 
    958                         fp= WaveData(p->waveHandle); 
    959                         SetNaN64(&p->result); 
    960                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    961                 case NT_FP64: 
    962                         dp= WaveData(p->waveHandle); 
     958                        fp= (float*)WaveData(p->waveHandle); 
     959                        SetNaN64(&p->result); 
     960                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     961                case NT_FP64: 
     962                        dp= (double*)WaveData(p->waveHandle); 
    963963                        p->result = FuzzySpheres(dp,q); 
    964964                        return 0; 
  • sans/XOP_Dev/SANSAnalysis/XOP/StructureFactor.c

    r823 r834  
    3232        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    3333                case NT_FP32: 
    34                         fp= WaveData(p->waveHandle); 
     34                        fp= (float*)WaveData(p->waveHandle); 
    3535                        SetNaN64(&p->result); 
    3636                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    3737                case NT_FP64: 
    38                         dp= WaveData(p->waveHandle); 
     38                        dp= (double*)WaveData(p->waveHandle); 
    3939                        p->result = HardSphereStruct(dp,q); 
    4040                        return 0; 
     
    6464        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    6565                case NT_FP32: 
    66                         fp= WaveData(p->waveHandle); 
     66                        fp= (float*)WaveData(p->waveHandle); 
    6767                        SetNaN64(&p->result); 
    6868                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    6969                case NT_FP64: 
    70                         dp= WaveData(p->waveHandle); 
     70                        dp= (double*)WaveData(p->waveHandle); 
    7171                        p->result = StickyHS_Struct(dp,q); 
    7272                        return 0; 
     
    102102        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    103103                case NT_FP32: 
    104                         fp= WaveData(p->waveHandle); 
     104                        fp= (float*)WaveData(p->waveHandle); 
    105105                        SetNaN64(&p->result); 
    106106                        XOPNotice("I think it's single precision\r"); 
    107107                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    108108                case NT_FP64: 
    109                         dp= WaveData(p->waveHandle); 
     109                        dp= (double*)WaveData(p->waveHandle); 
    110110                        p->result = SquareWellStruct(dp,q); 
    111111                        return 0; 
     
    137137        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    138138                case NT_FP32: 
    139                         fp= WaveData(p->waveHandle); 
     139                        fp= (float*)WaveData(p->waveHandle); 
    140140                        SetNaN64(&p->result); 
    141141                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    142142                case NT_FP64: 
    143                         dp= WaveData(p->waveHandle); 
     143                        dp= (double*)WaveData(p->waveHandle); 
    144144                        p->result = HayterPenfoldMSA(dp,q); 
    145145                        return 0; 
     
    221221         
    222222        //get the wave data 
    223         sq = WaveData(p->SQHandle); 
    224         qw = WaveData(p->QHandle);                                       
    225         cw = WaveData(p->CoefHandle);                                    
     223        sq = (double*)WaveData(p->SQHandle); 
     224        qw = (double*)WaveData(p->QHandle);                                      
     225        cw = (double*)WaveData(p->CoefHandle);                                   
    226226        npnts = WavePoints(p->QHandle);                                         // Number of points in q wave. 
    227227         
     
    307307         
    308308        //get the wave data 
    309         sq = WaveData(p->SQHandle); 
    310         qw = WaveData(p->QHandle);                                       
    311         cw = WaveData(p->CoefHandle);                                    
     309        sq = (double*)WaveData(p->SQHandle); 
     310        qw = (double*)WaveData(p->QHandle);                                      
     311        cw = (double*)WaveData(p->CoefHandle);                                   
    312312        npnts = WavePoints(p->QHandle);                                         // Number of points in q wave. 
    313313         
  • sans/XOP_Dev/SANSAnalysis/XOP/StructureFactor.h

    r756 r834  
    11// header for SphereFit.c 
    22 
    3 #include "XOPStructureAlignmentTwoByte.h" 
     3#pragma pack(2) 
    44 
    55/* structs */ 
     
    1818 
    1919 
    20 #include "XOPStructureAlignmentReset.h" 
     20#pragma pack() 
    2121 
    2222/* IGOR Fit Functions */ 
  • sans/XOP_Dev/SANSAnalysis/XOP/TwoPhase.c

    r452 r834  
    2626        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    2727                case NT_FP32: 
    28                         fp= WaveData(p->waveHandle); 
     28                        fp= (float*)WaveData(p->waveHandle); 
    2929            SetNaN64(&p->result); 
    3030                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07             
    3131                case NT_FP64: 
    32                         dp= WaveData(p->waveHandle); 
     32                        dp= (double*)WaveData(p->waveHandle); 
    3333                        p->result = TeubnerStreyModel(dp,q);                                                                                                                             
    3434                        return 0; 
     
    5757        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    5858                case NT_FP32: 
    59                         fp= WaveData(p->waveHandle); 
    60                         SetNaN64(&p->result); 
    61                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    62                 case NT_FP64: 
    63                         dp= WaveData(p->waveHandle); 
     59                        fp= (float*)WaveData(p->waveHandle); 
     60                        SetNaN64(&p->result); 
     61                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     62                case NT_FP64: 
     63                        dp= (double*)WaveData(p->waveHandle); 
    6464                        p->result = Power_Law_Model(dp,q); 
    6565                        return 0; 
     
    8989        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    9090                case NT_FP32: 
    91                         fp= WaveData(p->waveHandle); 
    92                         SetNaN64(&p->result); 
    93                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    94                 case NT_FP64: 
    95                         dp= WaveData(p->waveHandle); 
     91                        fp= (float*)WaveData(p->waveHandle); 
     92                        SetNaN64(&p->result); 
     93                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     94                case NT_FP64: 
     95                        dp= (double*)WaveData(p->waveHandle); 
    9696                        p->result = Peak_Lorentz_Model(dp,q); 
    9797                        return 0; 
     
    120120        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    121121                case NT_FP32: 
    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); 
     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                        p->result = Peak_Gauss_Model(dp,q); 
    128128                        return 0; 
     
    151151        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    152152                case NT_FP32: 
    153                         fp= WaveData(p->waveHandle); 
     153                        fp= (float*)WaveData(p->waveHandle); 
    154154                        SetNaN64(&p->result); 
    155155                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    156156                case NT_FP64: 
    157                         dp= WaveData(p->waveHandle); 
     157                        dp= (double*)WaveData(p->waveHandle); 
    158158                        p->result=Lorentz_Model(dp,q); 
    159159                        return 0; 
     
    182182        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    183183                case NT_FP32: 
    184                         fp= WaveData(p->waveHandle);            
    185                         SetNaN64(&p->result); 
    186                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    187                 case NT_FP64: 
    188                         dp= WaveData(p->waveHandle); 
     184                        fp= (float*)WaveData(p->waveHandle);            
     185                        SetNaN64(&p->result); 
     186                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     187                case NT_FP64: 
     188                        dp= (double*)WaveData(p->waveHandle); 
    189189            p->result = Fractal(dp,q); 
    190190                        return 0; 
     
    213213        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    214214                case NT_FP32: 
    215                         fp= WaveData(p->waveHandle); 
    216                         SetNaN64(&p->result); 
    217                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    218                 case NT_FP64: 
    219                         dp= WaveData(p->waveHandle); 
     215                        fp= (float*)WaveData(p->waveHandle); 
     216                        SetNaN64(&p->result); 
     217                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     218                case NT_FP64: 
     219                        dp= (double*)WaveData(p->waveHandle); 
    220220                        p->result = DAB_Model(dp,q); 
    221221                        return 0; 
     
    246246        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    247247                case NT_FP32: 
    248                         fp= WaveData(p->waveHandle); 
    249                         SetNaN64(&p->result); 
    250                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    251                 case NT_FP64: 
    252                         dp= WaveData(p->waveHandle); 
     248                        fp= (float*)WaveData(p->waveHandle); 
     249                        SetNaN64(&p->result); 
     250                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     251                case NT_FP64: 
     252                        dp= (double*)WaveData(p->waveHandle); 
    253253                        p-> result = OneLevel(dp,q); 
    254254                        return 0; 
     
    279279        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    280280                case NT_FP32: 
    281                         fp= WaveData(p->waveHandle); 
    282                         SetNaN64(&p->result); 
    283                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    284                 case NT_FP64: 
    285                         dp= WaveData(p->waveHandle); 
     281                        fp= (float*)WaveData(p->waveHandle); 
     282                        SetNaN64(&p->result); 
     283                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     284                case NT_FP64: 
     285                        dp= (double*)WaveData(p->waveHandle); 
    286286                        p->result = TwoLevel(dp, q); 
    287287                        return 0; 
     
    312312        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    313313                case NT_FP32: 
    314                         fp= WaveData(p->waveHandle); 
    315                         SetNaN64(&p->result); 
    316                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
    317                 case NT_FP64: 
    318                         dp= WaveData(p->waveHandle); 
     314                        fp= (float*)WaveData(p->waveHandle); 
     315                        SetNaN64(&p->result); 
     316                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07   
     317                case NT_FP64: 
     318                        dp= (double*)WaveData(p->waveHandle); 
    319319                        p->result = ThreeLevel(dp, q); 
    320320                        return 0; 
     
    345345        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    346346                case NT_FP32: 
    347                         fp= WaveData(p->waveHandle); 
    348                         SetNaN64(&p->result); 
    349                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    350                 case NT_FP64: 
    351                         dp= WaveData(p->waveHandle); 
     347                        fp= (float*)WaveData(p->waveHandle); 
     348                        SetNaN64(&p->result); 
     349                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     350                case NT_FP64: 
     351                        dp= (double*)WaveData(p->waveHandle); 
    352352                        p->result = FourLevel(dp,q); 
    353353                        return 0; 
     
    376376        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    377377                case NT_FP32: 
    378                         fp= WaveData(p->waveHandle); 
    379                         SetNaN64(&p->result); 
    380                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    381                 case NT_FP64: 
    382                         dp= WaveData(p->waveHandle); 
     378                        fp= (float*)WaveData(p->waveHandle); 
     379                        SetNaN64(&p->result); 
     380                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     381                case NT_FP64: 
     382                        dp= (double*)WaveData(p->waveHandle); 
    383383                        p->result = BroadPeak(dp,q); 
    384384                        return 0; 
     
    407407        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    408408                case NT_FP32: 
    409                         fp= WaveData(p->waveHandle); 
    410                         SetNaN64(&p->result); 
    411                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    412                 case NT_FP64: 
    413                         dp= WaveData(p->waveHandle); 
     409                        fp= (float*)WaveData(p->waveHandle); 
     410                        SetNaN64(&p->result); 
     411                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     412                case NT_FP64: 
     413                        dp= (double*)WaveData(p->waveHandle); 
    414414                        p->result = CorrLength(dp,q); 
    415415                        return 0; 
     
    438438        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    439439                case NT_FP32: 
    440                         fp= WaveData(p->waveHandle); 
    441                         SetNaN64(&p->result); 
    442                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    443                 case NT_FP64: 
    444                         dp= WaveData(p->waveHandle); 
     440                        fp= (float*)WaveData(p->waveHandle); 
     441                        SetNaN64(&p->result); 
     442                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     443                case NT_FP64: 
     444                        dp= (double*)WaveData(p->waveHandle); 
    445445                        p->result = TwoLorentzian(dp,q); 
    446446                        return 0; 
     
    469469        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    470470                case NT_FP32: 
    471                         fp= WaveData(p->waveHandle); 
    472                         SetNaN64(&p->result); 
    473                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    474                 case NT_FP64: 
    475                         dp= WaveData(p->waveHandle); 
     471                        fp= (float*)WaveData(p->waveHandle); 
     472                        SetNaN64(&p->result); 
     473                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     474                case NT_FP64: 
     475                        dp= (double*)WaveData(p->waveHandle); 
    476476                        p->result = TwoPowerLaw(dp,q); 
    477477                        return 0; 
     
    500500        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    501501                case NT_FP32: 
    502                         fp= WaveData(p->waveHandle); 
    503                         SetNaN64(&p->result); 
    504                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    505                 case NT_FP64: 
    506                         dp= WaveData(p->waveHandle); 
     502                        fp= (float*)WaveData(p->waveHandle); 
     503                        SetNaN64(&p->result); 
     504                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     505                case NT_FP64: 
     506                        dp= (double*)WaveData(p->waveHandle); 
    507507                        p->result = PolyGaussCoil(dp,q); 
    508508                        return 0; 
     
    531531        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    532532                case NT_FP32: 
    533                         fp= WaveData(p->waveHandle); 
    534                         SetNaN64(&p->result); 
    535                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    536                 case NT_FP64: 
    537                         dp= WaveData(p->waveHandle); 
     533                        fp= (float*)WaveData(p->waveHandle); 
     534                        SetNaN64(&p->result); 
     535                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     536                case NT_FP64: 
     537                        dp= (double*)WaveData(p->waveHandle); 
    538538                        p->result = GaussLorentzGel(dp,q); 
    539539                        return 0; 
     
    562562        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves. 
    563563                case NT_FP32: 
    564                         fp= WaveData(p->waveHandle); 
    565                         SetNaN64(&p->result); 
    566                         return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
    567                 case NT_FP64: 
    568                         dp= WaveData(p->waveHandle); 
     564                        fp= (float*)WaveData(p->waveHandle); 
     565                        SetNaN64(&p->result); 
     566                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                     
     567                case NT_FP64: 
     568                        dp= (double*)WaveData(p->waveHandle); 
    569569                        p->result = GaussianShell(dp,q); 
    570570                        return 0; 
  • sans/XOP_Dev/SANSAnalysis/lib/libCylinder.c

    r736 r834  
    1212 
    1313Warning: 
    14 The call to WaveData() below returns a pointer to the middle 
     14The call to (float*)WaveData() below returns a pointer to the middle 
    1515of an unlocked Macintosh handle. In the unlikely event that your 
    1616calculations could cause memory to move, you should copy the coefficient 
     
    7070 
    7171Warning: 
    72 The call to WaveData() below returns a pointer to the middle 
     72The call to (float*)WaveData() below returns a pointer to the middle 
    7373of an unlocked Macintosh handle. In the unlikely event that your 
    7474calculations could cause memory to move, you should copy the coefficient 
     
    152152 
    153153Warning: 
    154 The call to WaveData() below returns a pointer to the middle 
     154The call to (float*)WaveData() below returns a pointer to the middle 
    155155of an unlocked Macintosh handle. In the unlikely event that your 
    156156calculations could cause memory to move, you should copy the coefficient 
     
    235235 
    236236Warning: 
    237 The call to WaveData() below returns a pointer to the middle 
     237The call to (float*)WaveData() below returns a pointer to the middle 
    238238of an unlocked Macintosh handle. In the unlikely event that your 
    239239calculations could cause memory to move, you should copy the coefficient 
     
    307307 
    308308Warning: 
    309 The call to WaveData() below returns a pointer to the middle 
     309The call to (float*)WaveData() below returns a pointer to the middle 
    310310of an unlocked Macintosh handle. In the unlikely event that your 
    311311calculations could cause memory to move, you should copy the coefficient 
     
    396396 
    397397Warning: 
    398 The call to WaveData() below returns a pointer to the middle 
     398The call to (float*)WaveData() below returns a pointer to the middle 
    399399of an unlocked Macintosh handle. In the unlikely event that your 
    400400calculations could cause memory to move, you should copy the coefficient 
     
    451451 
    452452Warning: 
    453 The call to WaveData() below returns a pointer to the middle 
     453The call to (float*)WaveData() below returns a pointer to the middle 
    454454of an unlocked Macintosh handle. In the unlikely event that your 
    455455calculations could cause memory to move, you should copy the coefficient 
  • sans/XOP_Dev/SANSAnalysis/lib/libSANSAnalysis.h

    r756 r834  
    157157// rather than leave it to the whim of the compiler 
    158158/* SRK08 
    159 #include "XOPStructureAlignmentTwoByte.h" 
    160  
     159#pragma pack(2) 
     160  
    161161typedef struct { 
    162162    double scale; 
     
    182182} SmearCylinderParameters; 
    183183 
    184 #include "XOPStructureAlignmentReset.h" 
     184#pragma pack() 
    185185 
    186186/// 1D scattering function 
  • sans/XOP_Dev/SANSAnalysis/lib/libSphere.c

    r821 r834  
    10571057  
    10581058        Warning: 
    1059  The call to WaveData() below returns a pointer to the middle 
     1059 The call to (float*)WaveData() below returns a pointer to the middle 
    10601060 of an unlocked Macintosh handle. In the unlikely event that your 
    10611061 calculations could cause memory to move, you should copy the coefficient 
     
    11211121 // 
    11221122        Warning: 
    1123  The call to WaveData() below returns a pointer to the middle 
     1123 The call to (float*)WaveData() below returns a pointer to the middle 
    11241124 of an unlocked Macintosh handle. In the unlikely event that your 
    11251125 calculations could cause memory to move, you should copy the coefficient 
Note: See TracChangeset for help on using the changeset viewer.