# HG changeset patch
# User John W. Eaton <jwe@octave.org>
# Date 1627659965 14400
# Node ID 7faff48840eb85e0d96ff00b2b848a1130554de7
# Parent  aa98b5fdfbbb1524d13ae35fc977d26c7ce62c5f
prefer data over fortran_vec for read-only access to data

See also the discussion here: https://octave.discourse.group/t/rename-uses-of-fortran-vec-to-data-for-clarity/1439

* Array.h (const T * Array<T>::fortran_vec (void) const): Deprecate.
Change all uses to call data instead.

diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/__dsearchn__.cc
--- a/libinterp/corefcn/__dsearchn__.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/__dsearchn__.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -68,11 +68,11 @@
     }                                           \
   dd = sqrt (dd)
 
-  const double *pxi = xi.fortran_vec ();
+  const double *pxi = xi.data ();
   for (octave_idx_type i = 0; i < nxi; i++)
     {
       double d0;
-      const double *px = x.fortran_vec ();
+      const double *px = x.data ();
       DIST(d0, px, pxi, n);
       *pidx = 1.;
       for (octave_idx_type j = 1; j < nx; j++)
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/__magick_read__.cc
--- a/libinterp/corefcn/__magick_read__.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/__magick_read__.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -350,7 +350,7 @@
       if (imvec[def_elem].matte () && nargout >= 3)
         {
           const Matrix amap = maps(1).matrix_value ();
-          const double *amap_fvec = amap.fortran_vec ();
+          const double *amap_fvec = amap.data ();
 
           NDArray alpha (dim_vector (nRows, nCols, 1, nFrames));
           double *alpha_fvec = alpha.fortran_vec ();
@@ -958,7 +958,7 @@
   uint32NDArray out (img.dims ());
 
   octave_uint32 *out_fvec = out.fortran_vec ();
-  const P       *img_fvec = img.fortran_vec ();
+  const P       *img_fvec = img.data ();
 
   const octave_uint32 max = octave_uint32::max ();
   const octave_idx_type numel = img.numel ();
@@ -1028,7 +1028,7 @@
   // even if it's always the same.  We can least get a vector for the Colors.
   std::vector<Magick::ColorRGB> colormap;
   {
-    const double *cmap_fvec = cmap.fortran_vec ();
+    const double *cmap_fvec = cmap.data ();
     const octave_idx_type G_offset = cmap_size;
     const octave_idx_type B_offset = cmap_size * 2;
     for (octave_idx_type map_idx = 0; map_idx < cmap_size; map_idx++)
@@ -1061,7 +1061,7 @@
       // over the order of that colormap.  And that's why we set both.
       Magick::PixelPacket *pix = m_img.getPixels (0, 0, nCols, nRows);
       Magick::IndexPacket *ind = m_img.getIndexes ();
-      const P *img_fvec        = img.fortran_vec ();
+      const P *img_fvec        = img.data ();
 
       octave_idx_type GM_idx = 0;
       for (octave_idx_type column = 0; column < nCols; column++)
@@ -1092,7 +1092,7 @@
   // The initialized image will be black, this is for the other pixels
   const Magick::Color white ("white");
 
-  const bool *img_fvec = img.fortran_vec ();
+  const bool *img_fvec = img.data ();
   octave_idx_type img_idx = 0;
   for (octave_idx_type frame = 0; frame < nFrames; frame++)
     {
@@ -1181,8 +1181,8 @@
   const double divisor = static_cast<double> ((uint64_t (1) << bitdepth) - 1)
                          / MaxRGB;
 
-  const P *img_fvec = img.fortran_vec ();
-  const P *a_fvec   = alpha.fortran_vec ();
+  const P *img_fvec = img.data ();
+  const P *a_fvec   = alpha.data ();
   switch (type)
     {
     case Magick::GrayscaleType:
@@ -1251,7 +1251,7 @@
 
     case Magick::TrueColorType:
       {
-        // The fortran_vec offset for the green and blue channels
+        // The data offset for the green and blue channels
         const octave_idx_type G_offset = nCols * nRows;
         const octave_idx_type B_offset = nCols * nRows * 2;
         for (octave_idx_type frame = 0; frame < nFrames; frame++)
@@ -1287,7 +1287,7 @@
 
     case Magick::TrueColorMatteType:
       {
-        // The fortran_vec offset for the green and blue channels
+        // The data offset for the green and blue channels
         const octave_idx_type G_offset = nCols * nRows;
         const octave_idx_type B_offset = nCols * nRows * 2;
         for (octave_idx_type frame = 0; frame < nFrames; frame++)
@@ -1325,7 +1325,7 @@
 
     case Magick::ColorSeparationType:
       {
-        // The fortran_vec offset for the Magenta, Yellow, and blacK channels
+        // The data offset for the Magenta, Yellow, and blacK channels
         const octave_idx_type M_offset = nCols * nRows;
         const octave_idx_type Y_offset = nCols * nRows * 2;
         const octave_idx_type K_offset = nCols * nRows * 3;
@@ -1363,7 +1363,7 @@
 
     case Magick::ColorSeparationMatteType:
       {
-        // The fortran_vec offset for the Magenta, Yellow, and blacK channels
+        // The data offset for the Magenta, Yellow, and blacK channels
         const octave_idx_type M_offset = nCols * nRows;
         const octave_idx_type Y_offset = nCols * nRows * 2;
         const octave_idx_type K_offset = nCols * nRows * 3;
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/gcd.cc
--- a/libinterp/corefcn/gcd.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/gcd.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -346,8 +346,8 @@
 
       NDA gg (dv), xx (dv), yy (dv);
 
-      const T *aptr = aa.fortran_vec ();
-      const T *bptr = bb.fortran_vec ();
+      const T *aptr = aa.data ();
+      const T *bptr = bb.data ();
 
       bool inca = aa.numel () != 1;
       bool incb = bb.numel () != 1;
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/graphics.cc
--- a/libinterp/corefcn/graphics.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/graphics.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -5972,7 +5972,7 @@
 {
   ColumnVector retval (4, 1.0);
 
-  memcpy (retval.fortran_vec (), m.fortran_vec (), sizeof (double)*3);
+  memcpy (retval.fortran_vec (), m.data (), sizeof (double)*3);
 
   return retval;
 }
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/hex2num.cc
--- a/libinterp/corefcn/hex2num.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/hex2num.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -251,7 +251,7 @@
 
   string_vector sv (nel);
 
-  const T *pv = v.fortran_vec ();
+  const T *pv = v.data ();
 
   for (octave_idx_type i = 0; i < nel; i++)
     {
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/ls-mat5.cc
--- a/libinterp/corefcn/ls-mat5.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/ls-mat5.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -2221,14 +2221,12 @@
       if (tc.is_single_type ())
         {
           const FloatNDArray m = tc.float_array_value ();
-          ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
-                                         save_as_floats);
+          ret += save_mat5_array_length (m.data (), m.numel (), save_as_floats);
         }
       else
         {
           const NDArray m = tc.array_value ();
-          ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
-                                         save_as_floats);
+          ret += save_mat5_array_length (m.data (), m.numel (), save_as_floats);
         }
     }
   else if (tc.iscell ())
@@ -2245,14 +2243,12 @@
       if (tc.is_single_type ())
         {
           const FloatComplexNDArray m = tc.float_complex_array_value ();
-          ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
-                                         save_as_floats);
+          ret += save_mat5_array_length (m.data (), m.numel (), save_as_floats);
         }
       else
         {
           const ComplexNDArray m = tc.complex_array_value ();
-          ret += save_mat5_array_length (m.fortran_vec (), m.numel (),
-                                         save_as_floats);
+          ret += save_mat5_array_length (m.data (), m.numel (), save_as_floats);
         }
     }
   else if (tc.isstruct () || tc.is_inline_function () || tc.isobject ())
@@ -2614,55 +2610,55 @@
     {
       int8NDArray m = tc.int8_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), -1, m.numel ());
+      write_mat5_integer_data (os, m.data (), -1, m.numel ());
     }
   else if (cname == "int16")
     {
       int16NDArray m = tc.int16_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), -2, m.numel ());
+      write_mat5_integer_data (os, m.data (), -2, m.numel ());
     }
   else if (cname == "int32")
     {
       int32NDArray m = tc.int32_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), -4, m.numel ());
+      write_mat5_integer_data (os, m.data (), -4, m.numel ());
     }
   else if (cname == "int64")
     {
       int64NDArray m = tc.int64_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), -8, m.numel ());
+      write_mat5_integer_data (os, m.data (), -8, m.numel ());
     }
   else if (cname == "uint8")
     {
       uint8NDArray m = tc.uint8_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), 1, m.numel ());
+      write_mat5_integer_data (os, m.data (), 1, m.numel ());
     }
   else if (cname == "uint16")
     {
       uint16NDArray m = tc.uint16_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), 2, m.numel ());
+      write_mat5_integer_data (os, m.data (), 2, m.numel ());
     }
   else if (cname == "uint32")
     {
       uint32NDArray m = tc.uint32_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), 4, m.numel ());
+      write_mat5_integer_data (os, m.data (), 4, m.numel ());
     }
   else if (cname == "uint64")
     {
       uint64NDArray m = tc.uint64_array_value ();
 
-      write_mat5_integer_data (os, m.fortran_vec (), 8, m.numel ());
+      write_mat5_integer_data (os, m.data (), 8, m.numel ());
     }
   else if (tc.islogical ())
     {
       uint8NDArray m (tc.bool_array_value ());
 
-      write_mat5_integer_data (os, m.fortran_vec (), 1, m.numel ());
+      write_mat5_integer_data (os, m.data (), 1, m.numel ());
     }
   else if (tc.is_real_scalar () || tc.is_real_matrix () || tc.is_range ())
     {
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/tril.cc
--- a/libinterp/corefcn/tril.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/tril.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -46,7 +46,7 @@
 {
   octave_idx_type nr = a.rows ();
   octave_idx_type nc = a.columns ();
-  const T *avec = a.fortran_vec ();
+  const T *avec = a.data ();
   octave_idx_type zero = 0;
 
   if (pack)
@@ -88,7 +88,7 @@
 {
   octave_idx_type nr = a.rows ();
   octave_idx_type nc = a.columns ();
-  const T *avec = a.fortran_vec ();
+  const T *avec = a.data ();
   octave_idx_type zero = 0;
 
   if (pack)
diff -r aa98b5fdfbbb -r 7faff48840eb libinterp/corefcn/typecast.cc
--- a/libinterp/corefcn/typecast.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/libinterp/corefcn/typecast.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -322,7 +322,7 @@
 
   ArrayType retval (get_vec_dims (bitp.dims (), n));
 
-  const bool *bits = bitp.fortran_vec ();
+  const bool *bits = bitp.data ();
   char *packed = reinterpret_cast<char *> (retval.fortran_vec ());
 
   octave_idx_type m = n * sizeof (T);
@@ -470,7 +470,7 @@
 
   boolNDArray retval (get_vec_dims (array.dims (), n));
 
-  const char *packed = reinterpret_cast<const char *> (array.fortran_vec ());
+  const char *packed = reinterpret_cast<const char *> (array.data ());
   bool *bits = retval.fortran_vec ();
 
   octave_idx_type m = n / std::numeric_limits<unsigned char>::digits;
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/Array.h
--- a/liboctave/array/Array.h	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/Array.h	Fri Jul 30 11:46:05 2021 -0400
@@ -583,6 +583,7 @@
 
   const T * data (void) const { return m_slice_data; }
 
+  OCTAVE_DEPRECATED (7, "for read-only access, use 'data' method instead")
   const T * fortran_vec (void) const { return data (); }
 
   OCTARRAY_API T * fortran_vec (void);
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/CMatrix.cc
--- a/liboctave/array/CMatrix.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/CMatrix.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -1349,7 +1349,7 @@
       // Only calculate the condition number for LU/Cholesky
       if (typ == MatrixType::Upper)
         {
-          const Complex *tmp_data = fortran_vec ();
+          const Complex *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'U';
@@ -1377,7 +1377,7 @@
           ("permuted triangular matrix not implemented");
       else if (typ == MatrixType::Lower)
         {
-          const Complex *tmp_data = fortran_vec ();
+          const Complex *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'L';
@@ -1530,7 +1530,7 @@
         (*current_liboctave_error_handler)
           ("permuted triangular matrix not implemented");
 
-      const Complex *tmp_data = fortran_vec ();
+      const Complex *tmp_data = data ();
 
       retval = b;
       Complex *result = retval.fortran_vec ();
@@ -1628,7 +1628,7 @@
         (*current_liboctave_error_handler)
           ("permuted triangular matrix not implemented");
 
-      const Complex *tmp_data = fortran_vec ();
+      const Complex *tmp_data = data ();
 
       retval = b;
       Complex *result = retval.fortran_vec ();
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/CNDArray.cc
--- a/liboctave/array/CNDArray.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/CNDArray.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -73,7 +73,7 @@
   octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
   octave_idx_type dist = (stride == 1 ? n : 1);
 
-  const Complex *in (fortran_vec ());
+  const Complex *in (data ());
   ComplexNDArray retval (dv);
   Complex *out (retval.fortran_vec ());
 
@@ -104,7 +104,7 @@
   octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
   octave_idx_type dist = (stride == 1 ? n : 1);
 
-  const Complex *in (fortran_vec ());
+  const Complex *in (data ());
   ComplexNDArray retval (dv);
   Complex *out (retval.fortran_vec ());
 
@@ -124,7 +124,7 @@
     return ComplexNDArray ();
 
   dim_vector dv2 (dv(0), dv(1));
-  const Complex *in = fortran_vec ();
+  const Complex *in = data ();
   ComplexNDArray retval (dv);
   Complex *out = retval.fortran_vec ();
   octave_idx_type howmany = numel () / dv(0) / dv(1);
@@ -144,7 +144,7 @@
     return ComplexNDArray ();
 
   dim_vector dv2 (dv(0), dv(1));
-  const Complex *in = fortran_vec ();
+  const Complex *in = data ();
   ComplexNDArray retval (dv);
   Complex *out = retval.fortran_vec ();
   octave_idx_type howmany = numel () / dv(0) / dv(1);
@@ -162,7 +162,7 @@
   dim_vector dv = dims ();
   int rank = dv.ndims ();
 
-  const Complex *in (fortran_vec ());
+  const Complex *in (data ());
   ComplexNDArray retval (dv);
   Complex *out (retval.fortran_vec ());
 
@@ -177,7 +177,7 @@
   dim_vector dv = dims ();
   int rank = dv.ndims ();
 
-  const Complex *in (fortran_vec ());
+  const Complex *in (data ());
   ComplexNDArray retval (dv);
   Complex *out (retval.fortran_vec ());
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/CSparse.cc
--- a/liboctave/array/CSparse.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/CSparse.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -5754,7 +5754,7 @@
           B->dtype = CHOLMOD_DOUBLE;
           B->xtype = CHOLMOD_REAL;
 
-          B->x = const_cast<double *>(b.fortran_vec ());
+          B->x = const_cast<double *> (b.data ());
 
           cholmod_factor *L = CHOLMOD_NAME(analyze) (A, cm);
           CHOLMOD_NAME(factorize) (A, L, cm);
@@ -5835,7 +5835,7 @@
               const octave_idx_type *Ai = ridx ();
               const Complex *Ax = data ();
 #if defined (UMFPACK_SEPARATE_SPLIT)
-              const double *Bx = b.fortran_vec ();
+              const double *Bx = b.data ();
               OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
               for (octave_idx_type i = 0; i < b_nr; i++)
                 Bz[i] = 0.;
@@ -6283,7 +6283,7 @@
           B->dtype = CHOLMOD_DOUBLE;
           B->xtype = CHOLMOD_COMPLEX;
 
-          B->x = const_cast<Complex *>(b.fortran_vec ());
+          B->x = const_cast<Complex *> (b.data ());
 
           cholmod_factor *L = CHOLMOD_NAME(analyze) (A, cm);
           CHOLMOD_NAME(factorize) (A, L, cm);
@@ -6363,7 +6363,7 @@
               const octave_idx_type *Ap = cidx ();
               const octave_idx_type *Ai = ridx ();
               const Complex *Ax = data ();
-              const Complex *Bx = b.fortran_vec ();
+              const Complex *Bx = b.data ();
 
               retval.resize (b_nr, b_nc);
               Complex *Xx = retval.fortran_vec ();
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/DiagArray2.h
--- a/liboctave/array/DiagArray2.h	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/DiagArray2.h	Fri Jul 30 11:46:05 2021 -0400
@@ -168,7 +168,8 @@
 
   const T * data (void) const { return Array<T>::data (); }
 
-  const T * fortran_vec (void) const { return Array<T>::fortran_vec (); }
+  OCTAVE_DEPRECATED (7, "for read-only access, use 'data' method instead")
+  const T * fortran_vec (void) const { return Array<T>::data (); }
 
   T * fortran_vec (void) { return Array<T>::fortran_vec (); }
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/dMatrix.cc
--- a/liboctave/array/dMatrix.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/dMatrix.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -733,7 +733,7 @@
       nsamples = nc;
     }
 
-  const double *in (fortran_vec ());
+  const double *in (data ());
   Complex *out (retval.fortran_vec ());
 
   octave::fftw::fft (in, out, npts, nsamples);
@@ -763,7 +763,7 @@
     }
 
   ComplexMatrix tmp (*this);
-  Complex *in (tmp.fortran_vec ());
+  const Complex *in (tmp.data ());
   Complex *out (retval.fortran_vec ());
 
   octave::fftw::ifft (in, out, npts, nsamples);
@@ -776,7 +776,7 @@
 {
   dim_vector dv (rows (), cols ());
 
-  const double *in = fortran_vec ();
+  const double *in = data ();
   ComplexMatrix retval (rows (), cols ());
   octave::fftw::fftNd (in, retval.fortran_vec (), 2, dv);
 
@@ -1036,7 +1036,7 @@
       // Only calculate the condition number for LU/Cholesky
       if (typ == MatrixType::Upper)
         {
-          const double *tmp_data = fortran_vec ();
+          const double *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'U';
@@ -1064,7 +1064,7 @@
           ("permuted triangular matrix not implemented");
       else if (typ == MatrixType::Lower)
         {
-          const double *tmp_data = fortran_vec ();
+          const double *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'L';
@@ -1209,7 +1209,7 @@
         (*current_liboctave_error_handler)
           ("permuted triangular matrix not implemented");
 
-      const double *tmp_data = fortran_vec ();
+      const double *tmp_data = data ();
 
       retval = b;
       double *result = retval.fortran_vec ();
@@ -1307,7 +1307,7 @@
         (*current_liboctave_error_handler)
           ("permuted triangular matrix not implemented");
 
-      const double *tmp_data = fortran_vec ();
+      const double *tmp_data = data ();
 
       retval = b;
       double *result = retval.fortran_vec ();
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/dNDArray.cc
--- a/liboctave/array/dNDArray.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/dNDArray.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -47,7 +47,7 @@
 NDArray::NDArray (const Array<octave_idx_type>& a, bool zero_based,
                   bool negative_to_nan)
 {
-  const octave_idx_type *pa = a.fortran_vec ();
+  const octave_idx_type *pa = a.data ();
   resize (a.dims ());
   double *ptmp = fortran_vec ();
   if (negative_to_nan)
@@ -115,7 +115,7 @@
   octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
   octave_idx_type dist = (stride == 1 ? n : 1);
 
-  const double *in (fortran_vec ());
+  const double *in (data ());
   ComplexNDArray retval (dv);
   Complex *out (retval.fortran_vec ());
 
@@ -165,7 +165,7 @@
     return ComplexNDArray ();
 
   dim_vector dv2 (dv(0), dv(1));
-  const double *in = fortran_vec ();
+  const double *in = data ();
   ComplexNDArray retval (dv);
   Complex *out = retval.fortran_vec ();
   octave_idx_type howmany = numel () / dv(0) / dv(1);
@@ -202,7 +202,7 @@
   dim_vector dv = dims ();
   int rank = dv.ndims ();
 
-  const double *in (fortran_vec ());
+  const double *in (data ());
   ComplexNDArray retval (dv);
   Complex *out (retval.fortran_vec ());
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/dSparse.cc
--- a/liboctave/array/dSparse.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/dSparse.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -5796,7 +5796,7 @@
           B->dtype = CHOLMOD_DOUBLE;
           B->xtype = CHOLMOD_REAL;
 
-          B->x = const_cast<double *>(b.fortran_vec ());
+          B->x = const_cast<double *> (b.data ());
 
           cholmod_factor *L = CHOLMOD_NAME(analyze) (A, cm);
           CHOLMOD_NAME(factorize) (A, L, cm);
@@ -5868,7 +5868,7 @@
             {
               // one iterative refinement instead of the default two in UMFPACK
               Control (UMFPACK_IRSTEP) = 1;
-              const double *Bx = b.fortran_vec ();
+              const double *Bx = b.data ();
               retval.resize (b.rows (), b.cols ());
               double *result = retval.fortran_vec ();
               octave_idx_type b_nr = b.rows ();
@@ -6267,7 +6267,7 @@
           B->dtype = CHOLMOD_DOUBLE;
           B->xtype = CHOLMOD_COMPLEX;
 
-          B->x = const_cast<Complex *>(b.fortran_vec ());
+          B->x = const_cast<Complex *> (b.data ());
 
           cholmod_factor *L = CHOLMOD_NAME(analyze) (A, cm);
           CHOLMOD_NAME(factorize) (A, L, cm);
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/fCMatrix.cc
--- a/liboctave/array/fCMatrix.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/fCMatrix.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -1352,7 +1352,7 @@
       // Only calculate the condition number for LU/Cholesky
       if (typ == MatrixType::Upper)
         {
-          const FloatComplex *tmp_data = fortran_vec ();
+          const FloatComplex *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'U';
@@ -1380,7 +1380,7 @@
           ("permuted triangular matrix not implemented");
       else if (typ == MatrixType::Lower)
         {
-          const FloatComplex *tmp_data = fortran_vec ();
+          const FloatComplex *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'L';
@@ -1532,7 +1532,7 @@
               ("permuted triangular matrix not implemented");
           else
             {
-              const FloatComplex *tmp_data = fortran_vec ();
+              const FloatComplex *tmp_data = data ();
 
               retval = b;
               FloatComplex *result = retval.fortran_vec ();
@@ -1634,7 +1634,7 @@
               ("permuted triangular matrix not implemented");
           else
             {
-              const FloatComplex *tmp_data = fortran_vec ();
+              const FloatComplex *tmp_data = data ();
 
               retval = b;
               FloatComplex *result = retval.fortran_vec ();
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/fCNDArray.cc
--- a/liboctave/array/fCNDArray.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/fCNDArray.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -73,7 +73,7 @@
   octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
   octave_idx_type dist = (stride == 1 ? n : 1);
 
-  const FloatComplex *in (fortran_vec ());
+  const FloatComplex *in (data ());
   FloatComplexNDArray retval (dv);
   FloatComplex *out (retval.fortran_vec ());
 
@@ -104,7 +104,7 @@
   octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
   octave_idx_type dist = (stride == 1 ? n : 1);
 
-  const FloatComplex *in (fortran_vec ());
+  const FloatComplex *in (data ());
   FloatComplexNDArray retval (dv);
   FloatComplex *out (retval.fortran_vec ());
 
@@ -124,7 +124,7 @@
     return FloatComplexNDArray ();
 
   dim_vector dv2 (dv(0), dv(1));
-  const FloatComplex *in = fortran_vec ();
+  const FloatComplex *in = data ();
   FloatComplexNDArray retval (dv);
   FloatComplex *out = retval.fortran_vec ();
   octave_idx_type howmany = numel () / dv(0) / dv(1);
@@ -144,7 +144,7 @@
     return FloatComplexNDArray ();
 
   dim_vector dv2 (dv(0), dv(1));
-  const FloatComplex *in = fortran_vec ();
+  const FloatComplex *in = data ();
   FloatComplexNDArray retval (dv);
   FloatComplex *out = retval.fortran_vec ();
   octave_idx_type howmany = numel () / dv(0) / dv(1);
@@ -162,7 +162,7 @@
   dim_vector dv = dims ();
   int rank = dv.ndims ();
 
-  const FloatComplex *in (fortran_vec ());
+  const FloatComplex *in (data ());
   FloatComplexNDArray retval (dv);
   FloatComplex *out (retval.fortran_vec ());
 
@@ -177,7 +177,7 @@
   dim_vector dv = dims ();
   int rank = dv.ndims ();
 
-  const FloatComplex *in (fortran_vec ());
+  const FloatComplex *in (data ());
   FloatComplexNDArray retval (dv);
   FloatComplex *out (retval.fortran_vec ());
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/fMatrix.cc
--- a/liboctave/array/fMatrix.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/fMatrix.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -739,7 +739,7 @@
       nsamples = nc;
     }
 
-  const float *in (fortran_vec ());
+  const float *in (data ());
   FloatComplex *out (retval.fortran_vec ());
 
   octave::fftw::fft (in, out, npts, nsamples);
@@ -782,7 +782,7 @@
 {
   dim_vector dv (rows (), cols ());
 
-  const float *in = fortran_vec ();
+  const float *in = data ();
   FloatComplexMatrix retval (rows (), cols ());
   octave::fftw::fftNd (in, retval.fortran_vec (), 2, dv);
 
@@ -1045,7 +1045,7 @@
       // Only calculate the condition number for LU/Cholesky
       if (typ == MatrixType::Upper)
         {
-          const float *tmp_data = fortran_vec ();
+          const float *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'U';
@@ -1073,7 +1073,7 @@
           ("permuted triangular matrix not implemented");
       else if (typ == MatrixType::Lower)
         {
-          const float *tmp_data = fortran_vec ();
+          const float *tmp_data = data ();
           F77_INT info = 0;
           char norm = '1';
           char uplo = 'L';
@@ -1219,7 +1219,7 @@
               ("permuted triangular matrix not implemented");
           else
             {
-              const float *tmp_data = fortran_vec ();
+              const float *tmp_data = data ();
 
               retval = b;
               float *result = retval.fortran_vec ();
@@ -1322,7 +1322,7 @@
               ("permuted triangular matrix not implemented");
           else
             {
-              const float *tmp_data = fortran_vec ();
+              const float *tmp_data = data ();
 
               retval = b;
               float *result = retval.fortran_vec ();
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/array/fNDArray.cc
--- a/liboctave/array/fNDArray.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/array/fNDArray.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -73,7 +73,7 @@
   octave_idx_type nloop = (stride == 1 ? 1 : numel () / dv(dim) / stride);
   octave_idx_type dist = (stride == 1 ? n : 1);
 
-  const float *in (fortran_vec ());
+  const float *in (data ());
   FloatComplexNDArray retval (dv);
   FloatComplex *out (retval.fortran_vec ());
 
@@ -123,7 +123,7 @@
     return FloatComplexNDArray ();
 
   dim_vector dv2 (dv(0), dv(1));
-  const float *in = fortran_vec ();
+  const float *in = data ();
   FloatComplexNDArray retval (dv);
   FloatComplex *out = retval.fortran_vec ();
   octave_idx_type howmany = numel () / dv(0) / dv(1);
@@ -160,7 +160,7 @@
   dim_vector dv = dims ();
   int rank = dv.ndims ();
 
-  const float *in (fortran_vec ());
+  const float *in (data ());
   FloatComplexNDArray retval (dv);
   FloatComplex *out (retval.fortran_vec ());
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/numeric/bsxfun-defs.cc
--- a/liboctave/numeric/bsxfun-defs.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/numeric/bsxfun-defs.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -66,8 +66,8 @@
 
   Array<R> retval (dvr);
 
-  const X *xvec = x.fortran_vec ();
-  const Y *yvec = y.fortran_vec ();
+  const X *xvec = x.data ();
+  const Y *yvec = y.data ();
   R *rvec = retval.fortran_vec ();
 
   // Fold the common leading dimensions.
@@ -148,7 +148,7 @@
   octave_idx_type nd = r.ndims ();
   dvx.redim (nd);
 
-  const X *xvec = x.fortran_vec ();
+  const X *xvec = x.data ();
   R *rvec = r.fortran_vec ();
 
   // Fold the common leading dimensions.
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/numeric/eigs-base.cc
--- a/liboctave/numeric/eigs-base.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/numeric/eigs-base.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -245,7 +245,7 @@
   double rcond;
   MatrixType ltyp (MatrixType::Lower);
   M retval (n, b_nc);
-  const double *qv = Q.fortran_vec ();
+  const double *qv = Q.data ();
   for (octave_idx_type j = 0; j < b_nc; j++)
     {
       for (octave_idx_type i = 0; i < n; i++)
@@ -266,7 +266,7 @@
   MatrixType utyp (MatrixType::Upper);
   M tmp = U.solve (utyp, m, err, rcond, nullptr);
   M retval;
-  const double *qv = Q.fortran_vec ();
+  const double *qv = Q.data ();
 
   if (! err)
     {
@@ -537,7 +537,7 @@
           if (cholB)
             {
               Matrix tmp = sigma * b.transpose () * b;
-              const double *pB = permB.fortran_vec ();
+              const double *pB = permB.data ();
               double *p = AminusSigmaB.fortran_vec ();
 
               if (permB.numel ())
@@ -719,7 +719,7 @@
           if (cholB)
             {
               ComplexMatrix tmp = sigma * b.hermitian () * b;
-              const double *pB = permB.fortran_vec ();
+              const double *pB = permB.data ();
               Complex *p = AminusSigmaB.fortran_vec ();
 
               if (permB.numel ())
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/numeric/oct-convn.cc
--- a/liboctave/numeric/oct-convn.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/numeric/oct-convn.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -178,8 +178,8 @@
     if (c.isempty ())
       return c;
 
-    convolve_nd<T, R> (a.fortran_vec (), adims, adims.cumulative (),
-                       b.fortran_vec (), bdims, bdims.cumulative (),
+    convolve_nd<T, R> (a.data (), adims, adims.cumulative (),
+                       b.data (), bdims, bdims.cumulative (),
                        c.fortran_vec (), cdims.cumulative (),
                        nd, ct == convn_valid);
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/numeric/sparse-dmsolve.cc
--- a/liboctave/numeric/sparse-dmsolve.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/numeric/sparse-dmsolve.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -175,7 +175,7 @@
 {
   T *ax = a.fortran_vec ();
 
-  const T *bx = b.fortran_vec ();
+  const T *bx = b.data ();
 
   octave_idx_type anr = a.rows ();
 
@@ -295,7 +295,7 @@
   octave_idx_type b_nr = b.rows ();
   octave_idx_type b_nc = b.cols ();
 
-  const T *Bx = b.fortran_vec ();
+  const T *Bx = b.data ();
 
   a.resize (dim_vector (b_nr, b_nc));
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/numeric/sparse-lu.h
--- a/liboctave/numeric/sparse-lu.h	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/numeric/sparse-lu.h	Fri Jul 30 11:46:05 2021 -0400
@@ -106,9 +106,9 @@
 
       OCTAVE_API PermMatrix Pr_mat (void) const;
 
-      const octave_idx_type * row_perm (void) const { return P.fortran_vec (); }
+      const octave_idx_type * row_perm (void) const { return P.data (); }
 
-      const octave_idx_type * col_perm (void) const { return Q.fortran_vec (); }
+      const octave_idx_type * col_perm (void) const { return Q.data (); }
 
       double rcond (void) const { return cond; }
 
diff -r aa98b5fdfbbb -r 7faff48840eb liboctave/numeric/sparse-qr.cc
--- a/liboctave/numeric/sparse-qr.cc	Fri Jul 30 17:34:10 2021 +0200
+++ b/liboctave/numeric/sparse-qr.cc	Fri Jul 30 11:46:05 2021 -0400
@@ -737,7 +737,7 @@
       octave_idx_type nc = N->L->n;
       octave_idx_type nr = nrows;
 
-      const double *bvec = b.fortran_vec ();
+      const double *bvec = b.data ();
 
       Matrix ret (b_nr, b_nc);
       double *vec = ret.fortran_vec ();
@@ -1672,7 +1672,7 @@
       octave_idx_type nc = N->L->n;
       octave_idx_type nr = nrows;
       const cs_complex_t *bvec
-        = reinterpret_cast<const cs_complex_t *> (b.fortran_vec ());
+        = reinterpret_cast<const cs_complex_t *> (b.data ());
       ComplexMatrix ret (b_nr, b_nc);
       Complex *vec = ret.fortran_vec ();
 
@@ -2374,7 +2374,7 @@
       octave_idx_type b_nr = b.rows ();
 
       const cs_complex_t *bvec = reinterpret_cast<const cs_complex_t *>
-                                 (b.fortran_vec ());
+                                 (b.data ());
 
       ComplexMatrix x (nc, b_nc);
       cs_complex_t *vec = reinterpret_cast<cs_complex_t *>
@@ -2437,7 +2437,7 @@
       octave_idx_type b_nr = b.rows ();
 
       const cs_complex_t *bvec = reinterpret_cast<const cs_complex_t *>
-                                 (b.fortran_vec ());
+                                 (b.data ());
 
       ComplexMatrix x (nc, b_nc);
       cs_complex_t *vec = reinterpret_cast<cs_complex_t *> (x.fortran_vec ());