diff -ru scipy-1.2.1/scipy/odr/__odrpack.c scipy-1.2.1_patched/scipy/odr/__odrpack.c

--- scipy-1.2.1/scipy/odr/__odrpack.c	2019-01-28 04:57:51.000000000 +0100

+++ scipy-1.2.1_patched/scipy/odr/__odrpack.c	2019-06-06 16:11:32.947892754 +0200

@@ -9,6 +9,8 @@

  *

  */

+#define PY_SSIZE_T_CLEAN

+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION

 #include "odrpack.h"

@@ -44,7 +46,7 @@

                   double *fjacb, double *fjacd, int *istop)

 {

   PyObject *arg01, *arglist;

-  PyObject *result;

+  PyObject *result = NULL;

   PyArrayObject *result_array = NULL;

   PyArrayObject *pyXplusD;

   void *beta_dst;

@@ -57,14 +59,14 @@

       dim2[0] = *m;

       dim2[1] = *n;

       pyXplusD = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);

-      memcpy(pyXplusD->data, (void *)xplusd, (*m) * (*n) * sizeof(double));

+      memcpy(PyArray_DATA(pyXplusD), (void *)xplusd, (*m) * (*n) * sizeof(double));

     }

   else

     {

       npy_intp dim1[1];

       dim1[0] = *n;

       pyXplusD = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);

-      memcpy(pyXplusD->data, (void *)xplusd, (*n) * sizeof(double));

+      memcpy(PyArray_DATA(pyXplusD), (void *)xplusd, (*n) * sizeof(double));

     }

   PyTuple_SetItem(arg01, 0, odr_global.pyBeta);

@@ -84,7 +86,7 @@

   Py_DECREF(arg01);

   *istop = 0;

-  beta_dst = ((PyArrayObject *) (odr_global.pyBeta))->data;

+  beta_dst = (PyArray_DATA((PyArrayObject *) odr_global.pyBeta));

   if (beta != beta_dst) {

       memcpy(beta_dst, (void *)beta, (*np) * sizeof(double));

   }

@@ -121,7 +123,7 @@

                  "Result from function call is not a proper array of floats.");

         }

-      memcpy((void *)f, result_array->data, (*n) * (*nq) * sizeof(double));

+      memcpy((void *)f, PyArray_DATA(result_array), (*n) * (*nq) * sizeof(double));

       Py_DECREF(result_array);

     }

@@ -161,7 +163,7 @@

         {

           /* result_array should be rank-3 */

-          if (result_array->nd != 3)

+          if (PyArray_NDIM(result_array) != 3)

             {

               Py_DECREF(result_array);

               PYERR2(odr_error, "Beta Jacobian is not rank-3");

@@ -171,14 +173,14 @@

         {

           /* result_array should be rank-2 */

-          if (result_array->nd != 2)

+          if (PyArray_NDIM(result_array) != 2)

             {

               Py_DECREF(result_array);

               PYERR2(odr_error, "Beta Jacobian is not rank-2");

             }

         }

-      memcpy((void *)fjacb, result_array->data,

+      memcpy((void *)fjacb, PyArray_DATA(result_array),

              (*n) * (*nq) * (*np) * sizeof(double));

       Py_DECREF(result_array);

@@ -220,7 +222,7 @@

         {

           /* result_array should be rank-3 */

-          if (result_array->nd != 3)

+          if (PyArray_NDIM(result_array) != 3)

             {

               Py_DECREF(result_array);

               PYERR2(odr_error, "xplusd Jacobian is not rank-3");

@@ -230,7 +232,7 @@

         {

           /* result_array should be rank-2 */

-          if (result_array->nd != 2)

+          if (PyArray_NDIM(result_array) != 2)

             {

               Py_DECREF(result_array);

               PYERR2(odr_error, "xplusd Jacobian is not rank-2");

@@ -240,14 +242,14 @@

         {

           /* result_array should be rank-1 */

-          if (result_array->nd != 1)

+          if (PyArray_NDIM(result_array) != 1)

             {

               Py_DECREF(result_array);

               PYERR2(odr_error, "xplusd Jacobian is not rank-1");

             }

         }

-      memcpy((void *)fjacd, result_array->data,

+      memcpy((void *)fjacd, PyArray_DATA(result_array),

              (*n) * (*nq) * (*m) * sizeof(double));

       Py_DECREF(result_array);

     }

@@ -291,7 +293,7 @@

       return NULL;

   }

-  lwkmn = work->dimensions[0];

+  lwkmn = PyArray_DIMS(work)[0];

   F_FUNC(dwinf,DWINF)(&n, &m, &np, &nq, &ldwe, &ld2we, &isodr,

         &delta, &eps, &xplus, &fn, &sd, &vcv, &rvar, &wss, &wssde,

@@ -352,15 +354,15 @@

   wrk6--;

   wrk7--;

-  dim1[0] = beta->dimensions[0];

+  dim1[0] = PyArray_DIMS(beta)[0];

   sd_beta = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);

-  dim2[0] = beta->dimensions[0];

-  dim2[1] = beta->dimensions[0];

+  dim2[0] = PyArray_DIMS(beta)[0];

+  dim2[1] = PyArray_DIMS(beta)[0];

   cov_beta = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);

-  memcpy(sd_beta->data, (void *)((double *)(work->data) + sd),

+  memcpy(PyArray_DATA(sd_beta), (void *)((double *)(PyArray_DATA(work)) + sd),

          np * sizeof(double));

-  memcpy(cov_beta->data, (void *)((double *)(work->data) + vcv),

+  memcpy(PyArray_DATA(cov_beta), (void *)((double *)(PyArray_DATA(work)) + vcv),

          np * np * sizeof(double));

   if (!full_output)

@@ -427,21 +429,21 @@

           fnA = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);

         }

-      memcpy(deltaA->data, (void *)((double *)(work->data) + delta),

+      memcpy(PyArray_DATA(deltaA), (void *)((double *)(PyArray_DATA(work)) + delta),

              m * n * sizeof(double));

-      memcpy(epsA->data, (void *)((double *)(work->data) + eps),

+      memcpy(PyArray_DATA(epsA), (void *)((double *)(PyArray_DATA(work)) + eps),

              nq * n * sizeof(double));

-      memcpy(xplusA->data, (void *)((double *)(work->data) + xplus),

+      memcpy(PyArray_DATA(xplusA), (void *)((double *)(PyArray_DATA(work)) + xplus),

              m * n * sizeof(double));

-      memcpy(fnA->data, (void *)((double *)(work->data) + fn),

+      memcpy(PyArray_DATA(fnA), (void *)((double *)(PyArray_DATA(work)) + fn),

              nq * n * sizeof(double));

-      res_var = *((double *)(work->data) + rvar);

-      sum_square = *((double *)(work->data) + wss);

-      sum_square_delta = *((double *)(work->data) + wssde);

-      sum_square_eps = *((double *)(work->data) + wssep);

-      inv_condnum = *((double *)(work->data) + rcond);

-      rel_error = *((double *)(work->data) + eta);

+      res_var = *((double *)(PyArray_DATA(work)) + rvar);

+      sum_square = *((double *)(PyArray_DATA(work)) + wss);

+      sum_square_delta = *((double *)(PyArray_DATA(work)) + wssde);

+      sum_square_eps = *((double *)(PyArray_DATA(work)) + wssep);

+      inv_condnum = *((double *)(PyArray_DATA(work)) + rcond);

+      rel_error = *((double *)(PyArray_DATA(work)) + eta);

       retobj =

         Py_BuildValue

@@ -623,7 +625,7 @@

           PYERR(PyExc_ValueError,

                 "y could not be made into a suitable array");

         }

-      n = y->dimensions[y->nd - 1];     /* pick the last dimension */

+      n = PyArray_DIMS(y)[PyArray_NDIM(y) - 1];     /* pick the last dimension */

       if ((x =

            (PyArrayObject *) PyArray_CopyFromObject(px, NPY_DOUBLE, 1,

                                                     2)) == NULL)

@@ -631,18 +633,18 @@

           PYERR(PyExc_ValueError,

                 "x could not be made into a suitable array");

         }

-      if (n != x->dimensions[x->nd - 1])

+      if (n != PyArray_DIMS(x)[PyArray_NDIM(x) - 1])

         {

           PYERR(PyExc_ValueError,

                 "x and y don't have matching numbers of observations");

         }

-      if (y->nd == 1)

+      if (PyArray_NDIM(y) == 1)

         {

           nq = 1;

         }

       else

         {

-          nq = y->dimensions[0];

+          nq = PyArray_DIMS(y)[0];

         }

       ldx = ldy = n;

@@ -664,17 +666,17 @@

                 "x could not be made into a suitable array");

         }

-      n = x->dimensions[x->nd - 1];

+      n = PyArray_DIMS(x)[PyArray_NDIM(x) - 1];

       ldx = n;

     }

-  if (x->nd == 1)

+  if (PyArray_NDIM(x) == 1)

     {

       m = 1;

     }

   else

     {

-      m = x->dimensions[0];

+      m = PyArray_DIMS(x)[0];

     }                           /* x, y */

   if ((beta =

@@ -684,14 +686,14 @@

       PYERR(PyExc_ValueError,

             "initbeta could not be made into a suitable array");

     }

-  np = beta->dimensions[0];

+  np = PyArray_DIMS(beta)[0];

   if (pwe == NULL)

     {

       ldwe = ld2we = 1;

       dim1[0] = n;

       we = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);

-      ((double *)(we->data))[0] = -1.0;

+      ((double *)(PyArray_DATA(we)))[0] = -1.0;

     }

   else if (PyNumber_Check(pwe) && !PyArray_Check(pwe))

     {

@@ -711,11 +713,11 @@

       we = (PyArrayObject *) PyArray_SimpleNew(3, dim3, NPY_DOUBLE);

       if (implicit)

         {

-          ((double *)(we->data))[0] = val;

+          ((double *)(PyArray_DATA(we)))[0] = val;

         }

       else

         {

-          ((double *)(we->data))[0] = -val;

+          ((double *)(PyArray_DATA(we)))[0] = -val;

         }

       ldwe = ld2we = 1;

     }

@@ -730,29 +732,29 @@

           PYERR(PyExc_ValueError, "could not convert we to a suitable array");

         }

-      if (we->nd == 1 && nq == 1)

+      if (PyArray_NDIM(we) == 1 && nq == 1)

         {

           ldwe = n;

           ld2we = 1;

         }

-      else if (we->nd == 1 && we->dimensions[0] == nq)

+      else if (PyArray_NDIM(we) == 1 && PyArray_DIMS(we)[0] == nq)

         {

           /* we is a rank-1 array with diagonal weightings to be broadcast 

            * to all observations */

           ldwe = 1;

           ld2we = 1;

         }

-      else if (we->nd == 3 && we->dimensions[0] == nq

-               && we->dimensions[1] == nq && we->dimensions[2] == 1)

+      else if (PyArray_NDIM(we) == 3 && PyArray_DIMS(we)[0] == nq

+               && PyArray_DIMS(we)[1] == nq && PyArray_DIMS(we)[2] == 1)

         {

           /* we is a rank-3 array with the covariant weightings 

              to be broadcast to all observations */

           ldwe = 1;

           ld2we = nq;

         }

-      else if (we->nd == 2 && we->dimensions[0] == nq

-               && we->dimensions[1] == nq)

+      else if (PyArray_NDIM(we) == 2 && PyArray_DIMS(we)[0] == nq

+               && PyArray_DIMS(we)[1] == nq)

         {

           /* we is a rank-2 array with the full covariant weightings 

              to be broadcast to all observations */

@@ -760,16 +762,16 @@

           ld2we = nq;

         }

-      else if (we->nd == 2 && we->dimensions[0] == nq

-               && we->dimensions[1] == n)

+      else if (PyArray_NDIM(we) == 2 && PyArray_DIMS(we)[0] == nq

+               && PyArray_DIMS(we)[1] == n)

         {

           /* we is a rank-2 array with the diagonal elements of the 

              covariant weightings for each observation */

           ldwe = n;

           ld2we = 1;

         }

-      else if (we->nd == 3 && we->dimensions[0] == nq

-               && we->dimensions[1] == nq && we->dimensions[2] == n)

+      else if (PyArray_NDIM(we) == 3 && PyArray_DIMS(we)[0] == nq

+               && PyArray_DIMS(we)[1] == nq && PyArray_DIMS(we)[2] == n)

         {

           /* we is the full specification of the covariant weights

              for each observation */

@@ -788,7 +790,7 @@

       dim1[0] = m;

       wd = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);

-      ((double *)(wd->data))[0] = -1.0;

+      ((double *)(PyArray_DATA(wd)))[0] = -1.0;

     }

   else if (PyNumber_Check(pwd) && !PyArray_Check(pwd))

     {

@@ -806,7 +808,7 @@

       dim3[1] = 1;

       dim3[2] = m;

       wd = (PyArrayObject *) PyArray_SimpleNew(3, dim3, NPY_DOUBLE);

-      ((double *)(wd->data))[0] = -val;

+      ((double *)(PyArray_DATA(wd)))[0] = -val;

       ldwd = ld2wd = 1;

     }

   else if (PySequence_Check(pwd))

@@ -820,12 +822,12 @@

           PYERR(PyExc_ValueError, "could not convert wd to a suitable array");

         }

-      if (wd->nd == 1 && m == 1)

+      if (PyArray_NDIM(wd) == 1 && m == 1)

         {

           ldwd = n;

           ld2wd = 1;

         }

-      else if (wd->nd == 1 && wd->dimensions[0] == m)

+      else if (PyArray_NDIM(wd) == 1 && PyArray_DIMS(wd)[0] == m)

         {

           /* wd is a rank-1 array with diagonal weightings to be broadcast 

            * to all observations */

@@ -833,16 +835,16 @@

           ld2wd = 1;

         }

-      else if (wd->nd == 3 && wd->dimensions[0] == m

-               && wd->dimensions[1] == m && wd->dimensions[2] == 1)

+      else if (PyArray_NDIM(wd) == 3 && PyArray_DIMS(wd)[0] == m

+               && PyArray_DIMS(wd)[1] == m && PyArray_DIMS(wd)[2] == 1)

         {

           /* wd is a rank-3 array with the covariant wdightings 

              to be broadcast to all observations */

           ldwd = 1;

           ld2wd = m;

         }

-      else if (wd->nd == 2 && wd->dimensions[0] == m

-               && wd->dimensions[1] == m)

+      else if (PyArray_NDIM(wd) == 2 && PyArray_DIMS(wd)[0] == m

+               && PyArray_DIMS(wd)[1] == m)

         {

           /* wd is a rank-2 array with the full covariant weightings 

              to be broadcast to all observations */

@@ -850,16 +852,16 @@

           ld2wd = m;

         }

-      else if (wd->nd == 2 && wd->dimensions[0] == m

-               && wd->dimensions[1] == n)

+      else if (PyArray_NDIM(wd) == 2 && PyArray_DIMS(wd)[0] == m

+               && PyArray_DIMS(wd)[1] == n)

         {

           /* wd is a rank-2 array with the diagonal elements of the 

              covariant weightings for each observation */

           ldwd = n;

           ld2wd = 1;

         }

-      else if (wd->nd == 3 && wd->dimensions[0] == m

-               && wd->dimensions[1] == m && wd->dimensions[2] == n)

+      else if (PyArray_NDIM(wd) == 3 && PyArray_DIMS(wd)[0] == m

+               && PyArray_DIMS(wd)[1] == m && PyArray_DIMS(wd)[2] == n)

         {

           /* wd is the full specification of the covariant weights

              for each observation */

@@ -878,7 +880,7 @@

     {

       dim1[0] = np;

       ifixb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_INT);

-      *(int *)(ifixb->data) = -1;      /* set first element negative */

+      *(int *)(PyArray_DATA(ifixb)) = -1;      /* set first element negative */

     }

   else

     {

@@ -892,7 +894,7 @@

                 "could not convert ifixb to a suitable array");

         }

-      if (ifixb->dimensions[0] != np)

+      if (PyArray_DIMS(ifixb)[0] != np)

         {

           PYERR(PyExc_ValueError,

                 "could not convert ifixb to a suitable array");

@@ -904,7 +906,7 @@

       dim2[0] = m;

       dim2[1] = 1;

       ifixx = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_INT);

-      *(int *)(ifixx->data) = -1;      /* set first element negative */

+      *(int *)(PyArray_DATA(ifixx)) = -1;      /* set first element negative */

       ldifx = 1;

     }

   else

@@ -919,16 +921,16 @@

                 "could not convert ifixx to a suitable array");

         }

-      if (ifixx->nd == 1 && ifixx->dimensions[0] == m)

+      if (PyArray_NDIM(ifixx) == 1 && PyArray_DIMS(ifixx)[0] == m)

         {

           ldifx = 1;

         }

-      else if (ifixx->nd == 1 && ifixx->dimensions[0] == n && m == 1)

+      else if (PyArray_NDIM(ifixx) == 1 && PyArray_DIMS(ifixx)[0] == n && m == 1)

         {

           ldifx = n;

         }

-      else if (ifixx->nd == 2 && ifixx->dimensions[0] == m

-               && ifixx->dimensions[1] == n)

+      else if (PyArray_NDIM(ifixx) == 2 && PyArray_DIMS(ifixx)[0] == m

+               && PyArray_DIMS(ifixx)[1] == n)

         {

           ldifx = n;

         }

@@ -957,14 +959,14 @@

     {

       dim1[0] = np;

       stpb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);

-      *(double *)(stpb->data) = 0.0;

+      *(double *)(PyArray_DATA(stpb)) = 0.0;

     }

   else                          /* pstpb is a sequence */

     {

       if ((stpb =

            (PyArrayObject *) PyArray_CopyFromObject(pstpb, NPY_DOUBLE, 1,

                                                     1)) == NULL

-          || stpb->dimensions[0] != np)

+          || PyArray_DIMS(stpb)[0] != np)

         {

           PYERR(PyExc_ValueError,

                 "could not convert stpb to a suitable array");

@@ -976,7 +978,7 @@

       dim2[0] = 1;

       dim2[1] = m;

       stpd = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);

-      *(double *)(stpd->data) = 0.0;

+      *(double *)(PyArray_DATA(stpd)) = 0.0;

       ldstpd = 1;

     }

   else

@@ -989,16 +991,16 @@

                 "could not convert stpb to a suitable array");

         }

-      if (stpd->nd == 1 && stpd->dimensions[0] == m)

+      if (PyArray_NDIM(stpd) == 1 && PyArray_DIMS(stpd)[0] == m)

         {

           ldstpd = 1;

         }

-      else if (stpd->nd == 1 && stpd->dimensions[0] == n && m == 1)

+      else if (PyArray_NDIM(stpd) == 1 && PyArray_DIMS(stpd)[0] == n && m == 1)

         {

           ldstpd = n;

         }

-      else if (stpd->nd == 2 && stpd->dimensions[0] == n &&

-               stpd->dimensions[1] == m)

+      else if (PyArray_NDIM(stpd) == 2 && PyArray_DIMS(stpd)[0] == n &&

+               PyArray_DIMS(stpd)[1] == m)

         {

           ldstpd = n;

         }

@@ -1008,14 +1010,14 @@

     {

       dim1[0] = np;

       sclb = (PyArrayObject *) PyArray_SimpleNew(1, dim1, NPY_DOUBLE);

-      *(double *)(sclb->data) = 0.0;

+      *(double *)(PyArray_DATA(sclb)) = 0.0;

     }

   else                          /* psclb is a sequence */

     {

       if ((sclb =

            (PyArrayObject *) PyArray_CopyFromObject(psclb, NPY_DOUBLE, 1,

                                                     1)) == NULL

-          || sclb->dimensions[0] != np)

+          || PyArray_DIMS(sclb)[0] != np)

         {

           PYERR(PyExc_ValueError,

                 "could not convert sclb to a suitable array");

@@ -1027,7 +1029,7 @@

       dim2[0] = 1;

       dim2[1] = n;

       scld = (PyArrayObject *) PyArray_SimpleNew(2, dim2, NPY_DOUBLE);

-      *(double *)(scld->data) = 0.0;

+      *(double *)(PyArray_DATA(scld)) = 0.0;

       ldscld = 1;

     }

   else

@@ -1040,16 +1042,16 @@

                 "could not convert stpb to a suitable array");

         }

-      if (scld->nd == 1 && scld->dimensions[0] == m)

+      if (PyArray_NDIM(scld) == 1 && PyArray_DIMS(scld)[0] == m)

         {

           ldscld = 1;

         }

-      else if (scld->nd == 1 && scld->dimensions[0] == n && m == 1)

+      else if (PyArray_NDIM(scld) == 1 && PyArray_DIMS(scld)[0] == n && m == 1)

         {

           ldscld = n;

         }

-      else if (scld->nd == 2 && scld->dimensions[0] == n &&

-               scld->dimensions[1] == m)

+      else if (PyArray_NDIM(scld) == 2 && PyArray_DIMS(scld)[0] == n &&

+               PyArray_DIMS(scld)[1] == m)

         {

           ldscld = n;

         }

@@ -1110,9 +1112,9 @@

           PYERR(PyExc_ValueError,

                 "could not convert work to a suitable array");

         }

-      if (work->dimensions[0] < lwork)

+      if (PyArray_DIMS(work)[0] < lwork)

         {

-            printf("%d %d\n", work->dimensions[0], lwork);

+            printf("%ld %d\n", PyArray_DIMS(work)[0], lwork);

           PYERR(PyExc_ValueError, "work is too small");

         }

     }

@@ -1133,7 +1135,7 @@

                 "could not convert iwork to a suitable array");

         }

-      if (iwork->dimensions[0] < liwork)

+      if (PyArray_DIMS(iwork)[0] < liwork)

         {

           PYERR(PyExc_ValueError, "iwork is too small");

         }

@@ -1170,19 +1172,18 @@

   Py_INCREF(beta);

   odr_global.extra_args = extra_args;

   Py_XINCREF(extra_args);

-

-  /* now call DODRC */

-  F_FUNC(dodrc,DODRC)(fcn_callback, &n, &m, &np, &nq, (double *)(beta->data),

-        (double *)(y->data), &ldy, (double *)(x->data), &ldx,

-        (double *)(we->data), &ldwe, &ld2we,

-        (double *)(wd->data), &ldwd, &ld2wd,

-        (int *)(ifixb->data), (int *)(ifixx->data), &ldifx,

-        &job, &ndigit, &taufac, &sstol, &partol, &maxit,

-        &iprint, &lunerr, &lunrpt,

-        (double *)(stpb->data), (double *)(stpd->data), &ldstpd,

-        (double *)(sclb->data), (double *)(scld->data), &ldscld,

-        (double *)(work->data), &lwork, (int *)(iwork->data), &liwork,

-        &info;;

+   /* now call DODRC */

+   F_FUNC(dodrc,DODRC)(fcn_callback, &n, &m, &np, &nq, (double *)(PyArray_DATA(beta)),

+         (double *)(PyArray_DATA(y)), &ldy, (double *)(PyArray_DATA(x)), &ldx,

+         (double *)(PyArray_DATA(we)), &ldwe, &ld2we,

+         (double *)(PyArray_DATA(wd)), &ldwd, &ld2wd,

+         (int *)(PyArray_DATA(ifixb)), (int *)(PyArray_DATA(ifixx)), &ldifx,

+         &job, &ndigit, &taufac, &sstol, &partol, &maxit,

+         &iprint, &lunerr, &lunrpt,

+         (double *)(PyArray_DATA(stpb)), (double *)(PyArray_DATA(stpd)), &ldstpd,

+         (double *)(PyArray_DATA(sclb)), (double *)(PyArray_DATA(scld)), &ldscld,

+         (double *)(PyArray_DATA(work)), &lwork, (int *)(PyArray_DATA(iwork)), &liwork,

+         &info;;

   result = gen_output(n, m, np, nq, ldwe, ld2we,

                       beta, work, iwork, isodr, info, full_output);