Changeset 3371d81 in sasview for src/sas


Ignore:
Timestamp:
May 9, 2016 6:59:33 AM (9 years ago)
Author:
wojciech
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
aa4a549
Parents:
aff7904 (diff), 1d5f5c2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

setup.py fixed. Merged with Master

Location:
src/sas/sascalc
Files:
2 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/calculator/c_extensions/librefl.c

    r9e531f2 r4c29e4d  
    88#include <stdlib.h> 
    99#if defined(_MSC_VER) 
    10 #include "winFuncs.h" 
     10#define NEED_ERF 
    1111#endif 
     12 
     13 
     14 
     15#if defined(NEED_ERF) 
     16/* erf.c  - public domain implementation of error function erf(3m) 
     17 
     18reference - Haruhiko Okumura: C-gengo niyoru saishin algorithm jiten 
     19            (New Algorithm handbook in C language) (Gijyutsu hyouron 
     20            sha, Tokyo, 1991) p.227 [in Japanese]                 */ 
     21 
     22 
     23#ifdef _WIN32 
     24# include <float.h> 
     25# if !defined __MINGW32__ || defined __NO_ISOCEXT 
     26#  ifndef isnan 
     27#   define isnan(x) _isnan(x) 
     28#  endif 
     29#  ifndef isinf 
     30#   define isinf(x) (!_finite(x) && !_isnan(x)) 
     31#  endif 
     32#  ifndef finite 
     33#   define finite(x) _finite(x) 
     34#  endif 
     35# endif 
     36#endif 
     37 
     38static double q_gamma(double, double, double); 
     39 
     40/* Incomplete gamma function 
     41   1 / Gamma(a) * Int_0^x exp(-t) t^(a-1) dt  */ 
     42static double p_gamma(double a, double x, double loggamma_a) 
     43{ 
     44    int k; 
     45    double result, term, previous; 
     46 
     47    if (x >= 1 + a) return 1 - q_gamma(a, x, loggamma_a); 
     48    if (x == 0)     return 0; 
     49    result = term = exp(a * log(x) - x - loggamma_a) / a; 
     50    for (k = 1; k < 1000; k++) { 
     51        term *= x / (a + k); 
     52        previous = result;  result += term; 
     53        if (result == previous) return result; 
     54    } 
     55    fprintf(stderr, "erf.c:%d:p_gamma() could not converge.", __LINE__); 
     56    return result; 
     57} 
     58 
     59/* Incomplete gamma function 
     60   1 / Gamma(a) * Int_x^inf exp(-t) t^(a-1) dt  */ 
     61static double q_gamma(double a, double x, double loggamma_a) 
     62{ 
     63    int k; 
     64    double result, w, temp, previous; 
     65    double la = 1, lb = 1 + x - a;  /* Laguerre polynomial */ 
     66 
     67    if (x < 1 + a) return 1 - p_gamma(a, x, loggamma_a); 
     68    w = exp(a * log(x) - x - loggamma_a); 
     69    result = w / lb; 
     70    for (k = 2; k < 1000; k++) { 
     71        temp = ((k - 1 - a) * (lb - la) + (k + x) * lb) / k; 
     72        la = lb;  lb = temp; 
     73        w *= (k - 1 - a) / k; 
     74        temp = w / (la * lb); 
     75        previous = result;  result += temp; 
     76        if (result == previous) return result; 
     77    } 
     78    fprintf(stderr, "erf.c:%d:q_gamma() could not converge.", __LINE__); 
     79    return result; 
     80} 
     81 
     82#define LOG_PI_OVER_2 0.572364942924700087071713675675 /* log_e(PI)/2 */ 
     83 
     84double erf(double x) 
     85{ 
     86    if (!finite(x)) { 
     87        if (isnan(x)) return x;      /* erf(NaN)   = NaN   */ 
     88        return (x>0 ? 1.0 : -1.0);   /* erf(+-inf) = +-1.0 */ 
     89    } 
     90    if (x >= 0) return   p_gamma(0.5, x * x, LOG_PI_OVER_2); 
     91    else        return - p_gamma(0.5, x * x, LOG_PI_OVER_2); 
     92} 
     93 
     94double erfc(double x) 
     95{ 
     96    if (!finite(x)) { 
     97        if (isnan(x)) return x;      /* erfc(NaN)   = NaN      */ 
     98        return (x>0 ? 0.0 : 2.0);    /* erfc(+-inf) = 0.0, 2.0 */ 
     99    } 
     100    if (x >= 0) return  q_gamma(0.5, x * x, LOG_PI_OVER_2); 
     101    else        return  1 + p_gamma(0.5, x * x, LOG_PI_OVER_2); 
     102} 
     103#endif // NEED_ERF 
    12104 
    13105complex cassign(real, imag) 

  • src/sas/sascalc/calculator/c_extensions/sld2i.cpp

    r9e531f2 rb523c0e  
    164164        //Assume that pixel volumes are given in vol_pix in A^3 unit 
    165165        // Loop over q-values and multiply apply matrix 
    166         for(size_t i=0; i<npoints; i++){ 
     166        for(int i=0; i<npoints; i++){ 
    167167                sumj =0.0;               
    168                 for(size_t j=0; j<n_pix; j++){ 
     168                for(int j=0; j<n_pix; j++){ 
    169169                        //Isotropic: Assumes all slds are real (no magnetic) 
    170170                        //Also assumes there is no polarization: No dependency on spin 
    … …  
    183183                                //full calculation 
    184184                                //pragma omp parallel for 
    185                                 for(size_t k=0; k<n_pix; k++){ 
     185                                for(int k=0; k<n_pix; k++){ 
    186186                                        sld_j =  sldn_val[j] * sldn_val[k] * vol_pix[j] * vol_pix[k]; 
    187187                                        qr = (x_val[j]-x_val[k])*(x_val[j]-x_val[k])+ 

  • src/sas/sascalc/calculator/c_extensions/sld2i.hh

    r9e531f2 r4c29e4d  
    3939                        double s_theta); 
    4040        // compute function 
    41         virtual void genicomXY(int npoints, double* qx, double* qy, double *I_out); 
    42         virtual void genicom(int npoints, double* q, double *I_out); 
     41        void genicomXY(int npoints, double* qx, double* qy, double *I_out); 
     42        void genicom(int npoints, double* q, double *I_out); 
    4343}; 
    4444 

  • src/sas/sascalc/calculator/c_extensions/sld2i_module.cpp

    r9e531f2 rb523c0e  
    153153initsld2i(void) 
    154154{ 
    155     PyObject* m; 
    156  
    157     m = Py_InitModule3("sld2i", module_methods, 
    158                        "Sld2i module"); 
     155    Py_InitModule3("sld2i", module_methods, "Sld2i module"); 
    159156} 

  • src/sas/sascalc/pr/c_extensions/Cinvertor.c

    rb699768 rb523c0e  
    115115 
    116116        //self->params.x = data; 
    117         self->params.npoints = ndata; 
     117        self->params.npoints = (int)ndata; 
    118118        return Py_BuildValue("i", self->params.npoints); 
    119119} 
    … …  
    180180 
    181181        //self->params.y = data; 
    182         self->params.ny = ndata; 
     182        self->params.ny = (int)ndata; 
    183183        return Py_BuildValue("i", self->params.ny); 
    184184} 
    … …  
    245245 
    246246        //self->params.err = data; 
    247         self->params.nerr = ndata; 
     247        self->params.nerr = (int)ndata; 
    248248        return Py_BuildValue("i", self->params.nerr); 
    249249} 
    … …  
    523523    residuals = PyList_New(self->params.npoints); 
    524524 
    525     regterm = reg_term(pars, self->params.d_max, npars, nslice); 
     525    regterm = reg_term(pars, self->params.d_max, (int)npars, nslice); 
    526526 
    527527    for(i=0; i<self->params.npoints; i++) { 
    528         diff = self->params.y[i] - iq(pars, self->params.d_max, npars, self->params.x[i]); 
     528        diff = self->params.y[i] - iq(pars, self->params.d_max, (int)npars, self->params.x[i]); 
    529529        residual = diff*diff / (self->params.err[i]*self->params.err[i]); 
    530530 
    … …  
    573573    residuals = PyList_New(self->params.npoints); 
    574574 
    575     regterm = reg_term(pars, self->params.d_max, npars, nslice); 
     575    regterm = reg_term(pars, self->params.d_max, (int)npars, nslice); 
    576576 
    577577 
    578578    for(i=0; i<self->params.npoints; i++) { 
    579         diff = self->params.y[i] - pr(pars, self->params.d_max, npars, self->params.x[i]); 
     579        diff = self->params.y[i] - pr(pars, self->params.d_max, (int)npars, self->params.x[i]); 
    580580        residual = diff*diff / (self->params.err[i]*self->params.err[i]); 
    581581 
    … …  
    611611        OUTVECTOR(data_obj,pars,npars); 
    612612 
    613         iq_value = iq(pars, self->params.d_max, npars, q); 
     613        iq_value = iq(pars, self->params.d_max, (int)npars, q); 
    614614        return Py_BuildValue("f", iq_value); 
    615615} 
    … …  
    636636        OUTVECTOR(data_obj,pars,npars); 
    637637 
    638         iq_value = iq_smeared(pars, self->params.d_max, npars, 
     638        iq_value = iq_smeared(pars, self->params.d_max, (int)npars, 
    639639                                                        self->params.slit_height, self->params.slit_width, 
    640640                                                        q, 21); 
    … …  
    661661        OUTVECTOR(data_obj,pars,npars); 
    662662 
    663         pr_value = pr(pars, self->params.d_max, npars, r); 
     663        pr_value = pr(pars, self->params.d_max, (int)npars, r); 
    664664        return Py_BuildValue("f", pr_value); 
    665665} 
    … …  
    689689 
    690690        if (err_obj == Py_None) { 
    691                 pr_value = pr(pars, self->params.d_max, npars, r); 
     691                pr_value = pr(pars, self->params.d_max, (int)npars, r); 
    692692                pr_err_value = 0.0; 
    693693        } else { 
    694694                OUTVECTOR(err_obj,pars_err,npars2); 
    695                 pr_err(pars, pars_err, self->params.d_max, npars, r, &pr_value, &pr_err_value); 
     695                pr_err(pars, pars_err, self->params.d_max, (int)npars, r, &pr_value, &pr_err_value); 
    696696        } 
    697697        return Py_BuildValue("ff", pr_value, pr_err_value); 
    … …  
    728728        OUTVECTOR(data_obj,pars,npars); 
    729729 
    730         oscill = reg_term(pars, self->params.d_max, npars, 100); 
    731         norm   = int_p2(pars, self->params.d_max, npars, 100); 
     730        oscill = reg_term(pars, self->params.d_max, (int)npars, 100); 
     731        norm   = int_p2(pars, self->params.d_max, (int)npars, 100); 
    732732        return Py_BuildValue("f", sqrt(oscill/norm)/acos(-1.0)*self->params.d_max ); 
    733733 
    … …  
    749749        OUTVECTOR(data_obj,pars,npars); 
    750750 
    751         count = npeaks(pars, self->params.d_max, npars, 100); 
     751        count = npeaks(pars, self->params.d_max, (int)npars, 100); 
    752752 
    753753        return Py_BuildValue("i", count ); 
    … …  
    770770        OUTVECTOR(data_obj,pars,npars); 
    771771 
    772         fraction = positive_integral(pars, self->params.d_max, npars, 100); 
     772        fraction = positive_integral(pars, self->params.d_max, (int)npars, 100); 
    773773 
    774774        return Py_BuildValue("f", fraction ); 
    … …  
    795795        OUTVECTOR(err_obj,pars_err,npars2); 
    796796 
    797         fraction = positive_errors(pars, pars_err, self->params.d_max, npars, 51); 
     797        fraction = positive_errors(pars, pars_err, self->params.d_max, (int)npars, 51); 
    798798 
    799799        return Py_BuildValue("f", fraction ); 
    … …  
    815815        OUTVECTOR(data_obj,pars,npars); 
    816816 
    817         value = rg(pars, self->params.d_max, npars, 101); 
     817        value = rg(pars, self->params.d_max, (int)npars, 101); 
    818818 
    819819        return Py_BuildValue("f", value ); 
    … …  
    835835        OUTVECTOR(data_obj,pars,npars); 
    836836 
    837         value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, npars, 101); 
     837        value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, (int)npars, 101); 
    838838 
    839839        return Py_BuildValue("f", value ); 
Note: See TracChangeset for help on using the changeset viewer.