Changeset b523c0e in sasview

Timestamp:

May 6, 2016 4:19:24 PM (9 years ago)

Author:

Paul Kienzle <pkienzle@…>

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:

f567f92f

Parents:

4c29e4d

Message:

remove compiler warnings

Location:

src/sas/sascalc

Files:

• calculator/c_extensions/sld2i.cpp (modified) (2 diffs)
• calculator/c_extensions/sld2i_module.cpp (modified) (1 diff)
• pr/c_extensions/Cinvertor.c (modified) (15 diffs)

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

@@ -164 +164 @@
         //Assume that pixel volumes are given in vol_pix in A^3 unit
         // Loop over q-values and multiply apply matrix
-        for(size_t i=0; i<npoints; i++){
+        for(int i=0; i<npoints; i++){
                 sumj =0.0;              
-                for(size_t j=0; j<n_pix; j++){
+                for(int j=0; j<n_pix; j++){
                         //Isotropic: Assumes all slds are real (no magnetic)
                         //Also assumes there is no polarization: No dependency on spin
@@ -183 +183 @@
                                 //full calculation
                                 //pragma omp parallel for
-                                for(size_t k=0; k<n_pix; k++){
+                                for(int k=0; k<n_pix; k++){
                                         sld_j =  sldn_val[j] * sldn_val[k] * vol_pix[j] * vol_pix[k];
                                         qr = (x_val[j]-x_val[k])*(x_val[j]-x_val[k])+

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

@@ -153 +153 @@
 initsld2i(void)
 {
-    PyObject* m;
-
-    m = Py_InitModule3("sld2i", module_methods,
-                       "Sld2i module");
+    Py_InitModule3("sld2i", module_methods, "Sld2i module");
 }

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

@@ -115 +115 @@
 
         //self->params.x = data;
-        self->params.npoints = ndata;
+        self->params.npoints = (int)ndata;
         return Py_BuildValue("i", self->params.npoints);
 }
@@ -180 +180 @@
 
         //self->params.y = data;
-        self->params.ny = ndata;
+        self->params.ny = (int)ndata;
         return Py_BuildValue("i", self->params.ny);
 }
@@ -245 +245 @@
 
         //self->params.err = data;
-        self->params.nerr = ndata;
+        self->params.nerr = (int)ndata;
         return Py_BuildValue("i", self->params.nerr);
 }
@@ -523 +523 @@
     residuals = PyList_New(self->params.npoints);
 
-    regterm = reg_term(pars, self->params.d_max, npars, nslice);
+    regterm = reg_term(pars, self->params.d_max, (int)npars, nslice);
 
     for(i=0; i<self->params.npoints; i++) {
-        diff = self->params.y[i] - iq(pars, self->params.d_max, npars, self->params.x[i]);
+        diff = self->params.y[i] - iq(pars, self->params.d_max, (int)npars, self->params.x[i]);
         residual = diff*diff / (self->params.err[i]*self->params.err[i]);
 
@@ -573 +573 @@
     residuals = PyList_New(self->params.npoints);
 
-    regterm = reg_term(pars, self->params.d_max, npars, nslice);
+    regterm = reg_term(pars, self->params.d_max, (int)npars, nslice);
 
 
     for(i=0; i<self->params.npoints; i++) {
-        diff = self->params.y[i] - pr(pars, self->params.d_max, npars, self->params.x[i]);
+        diff = self->params.y[i] - pr(pars, self->params.d_max, (int)npars, self->params.x[i]);
         residual = diff*diff / (self->params.err[i]*self->params.err[i]);
 
@@ -611 +611 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        iq_value = iq(pars, self->params.d_max, npars, q);
+        iq_value = iq(pars, self->params.d_max, (int)npars, q);
         return Py_BuildValue("f", iq_value);
 }
@@ -636 +636 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        iq_value = iq_smeared(pars, self->params.d_max, npars,
+        iq_value = iq_smeared(pars, self->params.d_max, (int)npars,
                                                         self->params.slit_height, self->params.slit_width,
                                                         q, 21);
@@ -661 +661 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        pr_value = pr(pars, self->params.d_max, npars, r);
+        pr_value = pr(pars, self->params.d_max, (int)npars, r);
         return Py_BuildValue("f", pr_value);
 }
@@ -689 +689 @@
 
         if (err_obj == Py_None) {
-                pr_value = pr(pars, self->params.d_max, npars, r);
+                pr_value = pr(pars, self->params.d_max, (int)npars, r);
                 pr_err_value = 0.0;
         } else {
                 OUTVECTOR(err_obj,pars_err,npars2);
-                pr_err(pars, pars_err, self->params.d_max, npars, r, &pr_value, &pr_err_value);
+                pr_err(pars, pars_err, self->params.d_max, (int)npars, r, &pr_value, &pr_err_value);
         }
         return Py_BuildValue("ff", pr_value, pr_err_value);
@@ -728 +728 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        oscill = reg_term(pars, self->params.d_max, npars, 100);
-        norm   = int_p2(pars, self->params.d_max, npars, 100);
+        oscill = reg_term(pars, self->params.d_max, (int)npars, 100);
+        norm   = int_p2(pars, self->params.d_max, (int)npars, 100);
         return Py_BuildValue("f", sqrt(oscill/norm)/acos(-1.0)*self->params.d_max );
 
@@ -749 +749 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        count = npeaks(pars, self->params.d_max, npars, 100);
+        count = npeaks(pars, self->params.d_max, (int)npars, 100);
 
         return Py_BuildValue("i", count );
@@ -770 +770 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        fraction = positive_integral(pars, self->params.d_max, npars, 100);
+        fraction = positive_integral(pars, self->params.d_max, (int)npars, 100);
 
         return Py_BuildValue("f", fraction );
@@ -795 +795 @@
         OUTVECTOR(err_obj,pars_err,npars2);
 
-        fraction = positive_errors(pars, pars_err, self->params.d_max, npars, 51);
+        fraction = positive_errors(pars, pars_err, self->params.d_max, (int)npars, 51);
 
         return Py_BuildValue("f", fraction );
@@ -815 +815 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        value = rg(pars, self->params.d_max, npars, 101);
+        value = rg(pars, self->params.d_max, (int)npars, 101);
 
         return Py_BuildValue("f", value );
@@ -835 +835 @@
         OUTVECTOR(data_obj,pars,npars);
 
-        value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, npars, 101);
+        value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, (int)npars, 101);
 
         return Py_BuildValue("f", value );