Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r7ba6470 ra52f32f  
    55 * 
    66 */ 
     7#include <Python.h> 
     8#include "structmember.h" 
    79#include <stdio.h> 
    810#include <stdlib.h> 
    … …  
    1012#include <time.h> 
    1113 
    12 //#define Py_LIMITED_API 0x03050000 
    13 #include <Python.h> 
    14 #include <structmember.h> 
    15  
    16 // Vector binding glue 
    17 #if (PY_VERSION_HEX > 0x03000000) && !defined(Py_LIMITED_API) 
    18   // Assuming that a view into a writable vector points to a 
    19   // non-changing pointer for the duration of the C call, capture 
    20   // the view pointer and immediately free the view. 
    21   #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
    22     Py_buffer VEC_view; \ 
    23     int VEC_err = PyObject_GetBuffer(VEC_obj, &VEC_view, PyBUF_WRITABLE|PyBUF_FORMAT); \ 
    24     if (VEC_err < 0 || sizeof(*VEC_buf) != VEC_view.itemsize) return NULL; \ 
    25     VEC_buf = (typeof(VEC_buf))VEC_view.buf; \ 
    26     VEC_len = VEC_view.len/sizeof(*VEC_buf); \ 
    27     PyBuffer_Release(&VEC_view); \ 
    28   } while (0) 
    29 #else 
    30   #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 
    31     int VEC_err = PyObject_AsWriteBuffer(VEC_obj, (void **)(&VEC_buf), &VEC_len); \ 
    32     if (VEC_err < 0) return NULL; \ 
    33     VEC_len /= sizeof(*VEC_buf); \ 
    34   } while (0) 
    35 #endif 
    36  
    3714#include "invertor.h" 
     15 
    3816 
    3917/// Error object for raised exceptions 
    4018PyObject * CinvertorError; 
     19 
     20#define INVECTOR(obj,buf,len)                                                                           \ 
     21    do { \ 
     22        int err = PyObject_AsReadBuffer(obj, (const void **)(&buf), &len); \ 
     23        if (err < 0) return NULL; \ 
     24        len /= sizeof(*buf); \ 
     25    } while (0) 
     26 
     27#define OUTVECTOR(obj,buf,len) \ 
     28    do { \ 
     29        int err = PyObject_AsWriteBuffer(obj, (void **)(&buf), &len); \ 
     30        if (err < 0) return NULL; \ 
     31        len /= sizeof(*buf); \ 
     32    } while (0) 
     33 
    4134 
    4235// Class definition 
    … …  
    10699 
    107100        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    108         VECTOR(data_obj,data,ndata); 
     101        OUTVECTOR(data_obj,data,ndata); 
    109102 
    110103        free(self->params.x); 
    … …  
    138131 
    139132        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    140         VECTOR(data_obj, data, ndata); 
     133        OUTVECTOR(data_obj, data, ndata); 
    141134 
    142135        // Check that the input array is large enough 
    … …  
    171164 
    172165        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    173         VECTOR(data_obj,data,ndata); 
     166        OUTVECTOR(data_obj,data,ndata); 
    174167 
    175168        free(self->params.y); 
    … …  
    203196 
    204197        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    205         VECTOR(data_obj, data, ndata); 
     198        OUTVECTOR(data_obj, data, ndata); 
    206199 
    207200        // Check that the input array is large enough 
    … …  
    236229 
    237230        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    238         VECTOR(data_obj,data,ndata); 
     231        OUTVECTOR(data_obj,data,ndata); 
    239232 
    240233        free(self->params.err); 
    … …  
    268261 
    269262        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    270         VECTOR(data_obj, data, ndata); 
     263        OUTVECTOR(data_obj, data, ndata); 
    271264 
    272265        // Check that the input array is large enough 
    … …  
    524517        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    525518 
    526         VECTOR(data_obj,pars,npars); 
     519        OUTVECTOR(data_obj,pars,npars); 
    527520 
    528521    // PyList of residuals 
    … …  
    575568        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    576569 
    577         VECTOR(data_obj,pars,npars); 
     570        OUTVECTOR(data_obj,pars,npars); 
    578571 
    579572        // Should create this list only once and refill it 
    … …  
    616609 
    617610        if (!PyArg_ParseTuple(args, "Od", &data_obj, &q)) return NULL; 
    618         VECTOR(data_obj,pars,npars); 
     611        OUTVECTOR(data_obj,pars,npars); 
    619612 
    620613        iq_value = iq(pars, self->params.d_max, (int)npars, q); 
    … …  
    641634 
    642635        if (!PyArg_ParseTuple(args, "Od", &data_obj, &q)) return NULL; 
    643         VECTOR(data_obj,pars,npars); 
     636        OUTVECTOR(data_obj,pars,npars); 
    644637 
    645638        iq_value = iq_smeared(pars, self->params.d_max, (int)npars, 
    … …  
    666659 
    667660        if (!PyArg_ParseTuple(args, "Od", &data_obj, &r)) return NULL; 
    668         VECTOR(data_obj,pars,npars); 
     661        OUTVECTOR(data_obj,pars,npars); 
    669662 
    670663        pr_value = pr(pars, self->params.d_max, (int)npars, r); 
    … …  
    693686 
    694687        if (!PyArg_ParseTuple(args, "OOd", &data_obj, &err_obj, &r)) return NULL; 
    695         VECTOR(data_obj,pars,npars); 
     688        OUTVECTOR(data_obj,pars,npars); 
    696689 
    697690        if (err_obj == Py_None) { 
    … …  
    699692                pr_err_value = 0.0; 
    700693        } else { 
    701                 VECTOR(err_obj,pars_err,npars2); 
     694                OUTVECTOR(err_obj,pars_err,npars2); 
    702695                pr_err(pars, pars_err, self->params.d_max, (int)npars, r, &pr_value, &pr_err_value); 
    703696        } 
    … …  
    733726 
    734727        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    735         VECTOR(data_obj,pars,npars); 
     728        OUTVECTOR(data_obj,pars,npars); 
    736729 
    737730        oscill = reg_term(pars, self->params.d_max, (int)npars, 100); 
    … …  
    754747 
    755748        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    756         VECTOR(data_obj,pars,npars); 
     749        OUTVECTOR(data_obj,pars,npars); 
    757750 
    758751        count = npeaks(pars, self->params.d_max, (int)npars, 100); 
    … …  
    775768 
    776769        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    777         VECTOR(data_obj,pars,npars); 
     770        OUTVECTOR(data_obj,pars,npars); 
    778771 
    779772        fraction = positive_integral(pars, self->params.d_max, (int)npars, 100); 
    … …  
    799792 
    800793        if (!PyArg_ParseTuple(args, "OO", &data_obj, &err_obj)) return NULL; 
    801         VECTOR(data_obj,pars,npars); 
    802         VECTOR(err_obj,pars_err,npars2); 
     794        OUTVECTOR(data_obj,pars,npars); 
     795        OUTVECTOR(err_obj,pars_err,npars2); 
    803796 
    804797        fraction = positive_errors(pars, pars_err, self->params.d_max, (int)npars, 51); 
    … …  
    820813 
    821814        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    822         VECTOR(data_obj,pars,npars); 
     815        OUTVECTOR(data_obj,pars,npars); 
    823816 
    824817        value = rg(pars, self->params.d_max, (int)npars, 101); 
    … …  
    840833 
    841834        if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 
    842         VECTOR(data_obj,pars,npars); 
     835        OUTVECTOR(data_obj,pars,npars); 
    843836 
    844837        value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, (int)npars, 101); 
    … …  
    881874 
    882875        if (!PyArg_ParseTuple(args, "iiOO", &nfunc, &nr, &a_obj, &b_obj)) return NULL; 
    883         VECTOR(a_obj,a,n_a); 
    884         VECTOR(b_obj,b,n_b); 
     876        OUTVECTOR(a_obj,a,n_a); 
     877        OUTVECTOR(b_obj,b,n_b); 
    885878 
    886879        assert(n_b>=nfunc); 
    … …  
    954947 
    955948        if (!PyArg_ParseTuple(args, "iiOO", &nfunc, &nr, &a_obj, &cov_obj)) return NULL; 
    956         VECTOR(a_obj,a,n_a); 
    957         VECTOR(cov_obj,inv_cov,n_cov); 
     949        OUTVECTOR(a_obj,a,n_a); 
     950        OUTVECTOR(cov_obj,inv_cov,n_cov); 
    958951 
    959952        assert(n_cov>=nfunc*nfunc); 
    … …  
    988981 
    989982        if (!PyArg_ParseTuple(args, "iiO", &nfunc, &nr, &a_obj)) return NULL; 
    990         VECTOR(a_obj,a,n_a); 
     983        OUTVECTOR(a_obj,a,n_a); 
    991984 
    992985        assert(n_a>=nfunc*(nr+self->params.npoints)); 
    … …  
    11281121 
    11291122#define MODULE_DOC "C extension module for inversion to P(r)." 
    1130 #define MODULE_NAME "_pr_inversion" 
    1131 #define MODULE_INIT2 init_pr_inversion 
    1132 #define MODULE_INIT3 PyInit__pr_inversion 
     1123#define MODULE_NAME "pr_inversion" 
     1124#define MODULE_INIT2 initpr_inversion 
     1125#define MODULE_INIT3 PyInit_pr_inversion 
    11331126#define MODULE_METHODS module_methods 
    11341127 
Note: See TracChangeset for help on using the changeset viewer.