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

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sans/XOP_Dev/SANSAnalysis/XOP/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++) { 
Note: See TracChangeset for help on using the changeset viewer.