--- a/libinterp/corefcn/conv2.cc	Tue Jul 13 23:14:33 2021 -0400
+++ b/libinterp/corefcn/conv2.cc	Wed Jul 14 00:18:49 2021 -0400
@@ -73,7 +73,7 @@
 
   std::string shape = "full";   // default
   bool separable = false;
-  convn_type ct = convn_full;
+  octave::convn_type ct = octave::convn_full;
 
   if (nargin == 3)
     {
@@ -92,11 +92,11 @@
     error ("conv2: A and B must be 1-D vectors or 2-D matrices");
 
   if (shape == "full")
-    ct = convn_full;
+    ct = octave::convn_full;
   else if (shape == "same")
-    ct = convn_same;
+    ct = octave::convn_same;
   else if (shape == "valid")
-    ct = convn_valid;
+    ct = octave::convn_valid;
   else
     error ("conv2: SHAPE type not valid");
 
@@ -120,13 +120,13 @@
                 {
                   FloatColumnVector v1 (args(0).float_vector_value ());
                   FloatRowVector v2 (args(1).float_vector_value ());
-                  retval = convn (a, v1, v2, ct);
+                  retval = octave::convn (a, v1, v2, ct);
                 }
               else
                 {
                   FloatComplexColumnVector v1 (args(0).float_complex_vector_value ());
                   FloatComplexRowVector v2 (args(1).float_complex_vector_value ());
-                  retval = convn (a, v1, v2, ct);
+                  retval = octave::convn (a, v1, v2, ct);
                 }
             }
           else
@@ -134,7 +134,7 @@
               FloatColumnVector v1 (args(0).float_vector_value ());
               FloatRowVector v2 (args(1).float_vector_value ());
               FloatMatrix a (args(2).float_matrix_value ());
-              retval = convn (a, v1, v2, ct);
+              retval = octave::convn (a, v1, v2, ct);
             }
         }
       else
@@ -147,13 +147,13 @@
                 {
                   ColumnVector v1 (args(0).vector_value ());
                   RowVector v2 (args(1).vector_value ());
-                  retval = convn (a, v1, v2, ct);
+                  retval = octave::convn (a, v1, v2, ct);
                 }
               else
                 {
                   ComplexColumnVector v1 (args(0).complex_vector_value ());
                   ComplexRowVector v2 (args(1).complex_vector_value ());
-                  retval = convn (a, v1, v2, ct);
+                  retval = octave::convn (a, v1, v2, ct);
                 }
             }
           else
@@ -161,7 +161,7 @@
               ColumnVector v1 (args(0).vector_value ());
               RowVector v2 (args(1).vector_value ());
               Matrix a (args(2).matrix_value ());
-              retval = convn (a, v1, v2, ct);
+              retval = octave::convn (a, v1, v2, ct);
             }
         }
     } // if (separable)
@@ -175,19 +175,19 @@
               if (args(1).isreal ())
                 {
                   FloatMatrix b (args(1).float_matrix_value ());
-                  retval = convn (a, b, ct);
+                  retval = octave::convn (a, b, ct);
                 }
               else
                 {
                   FloatComplexMatrix b (args(1).float_complex_matrix_value ());
-                  retval = convn (a, b, ct);
+                  retval = octave::convn (a, b, ct);
                 }
             }
           else
             {
               FloatMatrix a (args(0).float_matrix_value ());
               FloatMatrix b (args(1).float_matrix_value ());
-              retval = convn (a, b, ct);
+              retval = octave::convn (a, b, ct);
             }
         }
       else
@@ -198,19 +198,19 @@
               if (args(1).isreal ())
                 {
                   Matrix b (args(1).matrix_value ());
-                  retval = convn (a, b, ct);
+                  retval = octave::convn (a, b, ct);
                 }
               else
                 {
                   ComplexMatrix b (args(1).complex_matrix_value ());
-                  retval = convn (a, b, ct);
+                  retval = octave::convn (a, b, ct);
                 }
             }
           else
             {
               Matrix a (args(0).matrix_value ());
               Matrix b (args(1).matrix_value ());
-              retval = convn (a, b, ct);
+              retval = octave::convn (a, b, ct);
             }
         }
 
@@ -332,17 +332,17 @@
     print_usage ();
 
   std::string shape = "full";   // default
-  convn_type ct = convn_full;
+  octave::convn_type ct = octave::convn_full;
 
   if (nargin == 3)
     shape = args(2).xstring_value ("convn: SHAPE must be a string");
 
   if (shape == "full")
-    ct = convn_full;
+    ct = octave::convn_full;
   else if (shape == "same")
-    ct = convn_same;
+    ct = octave::convn_same;
   else if (shape == "valid")
-    ct = convn_valid;
+    ct = octave::convn_valid;
   else
     error ("convn: SHAPE type not valid");
 
@@ -356,19 +356,19 @@
           if (args(1).isreal ())
             {
               FloatNDArray b (args(1).float_array_value ());
-              retval = convn (a, b, ct);
+              retval = octave::convn (a, b, ct);
             }
           else
             {
               FloatComplexNDArray b (args(1).float_complex_array_value ());
-              retval = convn (a, b, ct);
+              retval = octave::convn (a, b, ct);
             }
         }
       else
         {
           FloatNDArray a (args(0).float_array_value ());
           FloatNDArray b (args(1).float_array_value ());
-          retval = convn (a, b, ct);
+          retval = octave::convn (a, b, ct);
         }
     }
   else
@@ -379,19 +379,19 @@
           if (args(1).isreal ())
             {
               NDArray b (args(1).array_value ());
-              retval = convn (a, b, ct);
+              retval = octave::convn (a, b, ct);
             }
           else
             {
               ComplexNDArray b (args(1).complex_array_value ());
-              retval = convn (a, b, ct);
+              retval = octave::convn (a, b, ct);
             }
         }
       else
         {
           NDArray a (args(0).array_value ());
           NDArray b (args(1).array_value ());
-          retval = convn (a, b, ct);
+          retval = octave::convn (a, b, ct);
         }
     }
 

--- a/liboctave/numeric/oct-convn.cc	Tue Jul 13 23:14:33 2021 -0400
+++ b/liboctave/numeric/oct-convn.cc	Wed Jul 14 00:18:49 2021 -0400
@@ -50,14 +50,16 @@
 #include "fRowVector.h"
 #include "oct-convn.h"
 
-// 2d convolution with a matrix kernel.
-template <typename T, typename R>
-static void
-convolve_2d (const T *a, F77_INT ma, F77_INT na,
-             const R *b, F77_INT mb, F77_INT nb,
-             T *c, bool inner);
+namespace octave
+{
+  // 2d convolution with a matrix kernel.
+  template <typename T, typename R>
+  static void
+  convolve_2d (const T *a, F77_INT ma, F77_INT na,
+               const R *b, F77_INT mb, F77_INT nb,
+               T *c, bool inner);
 
-// Forward instances to our Fortran implementations.
+  // Forward instances to our Fortran implementations.
 #define FORWARD_IMPL(T_CXX, R_CXX, T, R, T_CAST, T_CONST_CAST,          \
                      R_CONST_CAST, f, F)                                \
   extern "C"                                                            \
@@ -87,112 +89,112 @@
                                        T_CAST (c)));                    \
   }
 
-FORWARD_IMPL (double, double, F77_DBLE, F77_DBLE, , , , d, D)
-FORWARD_IMPL (float, float, F77_REAL, F77_REAL, , , , s, S)
+  FORWARD_IMPL (double, double, F77_DBLE, F77_DBLE, , , , d, D)
+  FORWARD_IMPL (float, float, F77_REAL, F77_REAL, , , , s, S)
 
-FORWARD_IMPL (std::complex<double>, std::complex<double>,
-              F77_DBLE_CMPLX, F77_DBLE_CMPLX, F77_DBLE_CMPLX_ARG,
-              F77_CONST_DBLE_CMPLX_ARG, F77_CONST_DBLE_CMPLX_ARG, z, Z)
-FORWARD_IMPL (std::complex<float>, std::complex<float>,
-              F77_CMPLX, F77_CMPLX, F77_CMPLX_ARG,
-              F77_CONST_CMPLX_ARG, F77_CONST_CMPLX_ARG, c, C)
+  FORWARD_IMPL (std::complex<double>, std::complex<double>,
+                F77_DBLE_CMPLX, F77_DBLE_CMPLX, F77_DBLE_CMPLX_ARG,
+                F77_CONST_DBLE_CMPLX_ARG, F77_CONST_DBLE_CMPLX_ARG, z, Z)
+  FORWARD_IMPL (std::complex<float>, std::complex<float>,
+                F77_CMPLX, F77_CMPLX, F77_CMPLX_ARG,
+                F77_CONST_CMPLX_ARG, F77_CONST_CMPLX_ARG, c, C)
 
-FORWARD_IMPL (std::complex<double>, double,
-              F77_DBLE_CMPLX, F77_DBLE, F77_DBLE_CMPLX_ARG,
-              F77_CONST_DBLE_CMPLX_ARG, , zd, ZD)
-FORWARD_IMPL (std::complex<float>, float, F77_CMPLX, F77_REAL, F77_CMPLX_ARG,
-              F77_CONST_CMPLX_ARG, , cs, CS)
+  FORWARD_IMPL (std::complex<double>, double,
+                F77_DBLE_CMPLX, F77_DBLE, F77_DBLE_CMPLX_ARG,
+                F77_CONST_DBLE_CMPLX_ARG, , zd, ZD)
+  FORWARD_IMPL (std::complex<float>, float, F77_CMPLX, F77_REAL, F77_CMPLX_ARG,
+                F77_CONST_CMPLX_ARG, , cs, CS)
 
-template <typename T, typename R>
-void convolve_nd (const T *a, const dim_vector& ad, const dim_vector& acd,
-                  const R *b, const dim_vector& bd, const dim_vector& bcd,
-                  T *c, const dim_vector& ccd, int nd, bool inner)
-{
-  if (nd == 2)
-    {
-      F77_INT ad0 = octave::to_f77_int (ad(0));
-      F77_INT ad1 = octave::to_f77_int (ad(1));
+  template <typename T, typename R>
+  void convolve_nd (const T *a, const dim_vector& ad, const dim_vector& acd,
+                    const R *b, const dim_vector& bd, const dim_vector& bcd,
+                    T *c, const dim_vector& ccd, int nd, bool inner)
+  {
+    if (nd == 2)
+      {
+        F77_INT ad0 = octave::to_f77_int (ad(0));
+        F77_INT ad1 = octave::to_f77_int (ad(1));
 
-      F77_INT bd0 = octave::to_f77_int (bd(0));
-      F77_INT bd1 = octave::to_f77_int (bd(1));
+        F77_INT bd0 = octave::to_f77_int (bd(0));
+        F77_INT bd1 = octave::to_f77_int (bd(1));
 
-      convolve_2d<T, R> (a, ad0, ad1, b, bd0, bd1, c, inner);
-    }
-  else
-    {
-      octave_idx_type ma = acd(nd-2);
-      octave_idx_type na = ad(nd-1);
-      octave_idx_type mb = bcd(nd-2);
-      octave_idx_type nb = bd(nd-1);
-      octave_idx_type ldc = ccd(nd-2);
+        convolve_2d<T, R> (a, ad0, ad1, b, bd0, bd1, c, inner);
+      }
+    else
+      {
+        octave_idx_type ma = acd(nd-2);
+        octave_idx_type na = ad(nd-1);
+        octave_idx_type mb = bcd(nd-2);
+        octave_idx_type nb = bd(nd-1);
+        octave_idx_type ldc = ccd(nd-2);
 
-      if (inner)
-        {
-          for (octave_idx_type ja = 0; ja < na - nb + 1; ja++)
-            for (octave_idx_type jb = 0; jb < nb; jb++)
-              convolve_nd<T, R> (a + ma*(ja+jb), ad, acd,
-                                 b + mb*(nb-jb-1), bd, bcd,
-                                 c + ldc*ja, ccd, nd-1, inner);
-        }
-      else
-        {
-          for (octave_idx_type ja = 0; ja < na; ja++)
-            for (octave_idx_type jb = 0; jb < nb; jb++)
-              convolve_nd<T, R> (a + ma*ja, ad, acd, b + mb*jb, bd, bcd,
-                                 c + ldc*(ja+jb), ccd, nd-1, inner);
-        }
-    }
-}
+        if (inner)
+          {
+            for (octave_idx_type ja = 0; ja < na - nb + 1; ja++)
+              for (octave_idx_type jb = 0; jb < nb; jb++)
+                convolve_nd<T, R> (a + ma*(ja+jb), ad, acd,
+                                   b + mb*(nb-jb-1), bd, bcd,
+                                   c + ldc*ja, ccd, nd-1, inner);
+          }
+        else
+          {
+            for (octave_idx_type ja = 0; ja < na; ja++)
+              for (octave_idx_type jb = 0; jb < nb; jb++)
+                convolve_nd<T, R> (a + ma*ja, ad, acd, b + mb*jb, bd, bcd,
+                                   c + ldc*(ja+jb), ccd, nd-1, inner);
+          }
+      }
+  }
 
-// Arbitrary convolutor.
-// The 2nd array is assumed to be the smaller one.
-template <typename T, typename R>
-static MArray<T>
-convolve (const MArray<T>& a, const MArray<R>& b,
-          convn_type ct)
-{
-  if (a.isempty () || b.isempty ())
-    return MArray<T> ();
+  // Arbitrary convolutor.
+  // The 2nd array is assumed to be the smaller one.
+  template <typename T, typename R>
+  static MArray<T>
+  convolve (const MArray<T>& a, const MArray<R>& b,
+            convn_type ct)
+  {
+    if (a.isempty () || b.isempty ())
+      return MArray<T> ();
 
-  int nd = std::max (a.ndims (), b.ndims ());
-  const dim_vector adims = a.dims ().redim (nd);
-  const dim_vector bdims = b.dims ().redim (nd);
-  dim_vector cdims = dim_vector::alloc (nd);
+    int nd = std::max (a.ndims (), b.ndims ());
+    const dim_vector adims = a.dims ().redim (nd);
+    const dim_vector bdims = b.dims ().redim (nd);
+    dim_vector cdims = dim_vector::alloc (nd);
 
-  for (int i = 0; i < nd; i++)
-    {
-      if (ct == convn_valid)
-        cdims(i) = std::max (adims(i) - bdims(i) + 1,
-                             static_cast<octave_idx_type> (0));
-      else
-        cdims(i) = std::max (adims(i) + bdims(i) - 1,
-                             static_cast<octave_idx_type> (0));
-    }
+    for (int i = 0; i < nd; i++)
+      {
+        if (ct == convn_valid)
+          cdims(i) = std::max (adims(i) - bdims(i) + 1,
+                               static_cast<octave_idx_type> (0));
+        else
+          cdims(i) = std::max (adims(i) + bdims(i) - 1,
+                               static_cast<octave_idx_type> (0));
+      }
 
-  MArray<T> c (cdims, T ());
+    MArray<T> c (cdims, T ());
 
-  // "valid" shape can sometimes result in empty matrices which must avoid
-  // calling Fortran code which does not expect this (bug #52067)
-  if (c.isempty ())
-    return c;
+    // "valid" shape can sometimes result in empty matrices which must avoid
+    // calling Fortran code which does not expect this (bug #52067)
+    if (c.isempty ())
+      return c;
 
-  convolve_nd<T, R> (a.fortran_vec (), adims, adims.cumulative (),
-                     b.fortran_vec (), bdims, bdims.cumulative (),
-                     c.fortran_vec (), cdims.cumulative (),
-                     nd, ct == convn_valid);
+    convolve_nd<T, R> (a.fortran_vec (), adims, adims.cumulative (),
+                       b.fortran_vec (), bdims, bdims.cumulative (),
+                       c.fortran_vec (), cdims.cumulative (),
+                       nd, ct == convn_valid);
 
-  if (ct == convn_same)
-    {
-      // Pick the relevant part.
-      Array<octave::idx_vector> sidx (dim_vector (nd, 1));
+    if (ct == convn_same)
+      {
+        // Pick the relevant part.
+        Array<octave::idx_vector> sidx (dim_vector (nd, 1));
 
-      for (int i = 0; i < nd; i++)
-        sidx(i) = octave::idx_vector::make_range (bdims(i)/2, 1, adims(i));
-      c = c.index (sidx);
-    }
+        for (int i = 0; i < nd; i++)
+          sidx(i) = octave::idx_vector::make_range (bdims(i)/2, 1, adims(i));
+        c = c.index (sidx);
+      }
 
-  return c;
-}
+    return c;
+  }
 
 #define CONV_DEFS(TPREF, RPREF)                                         \
   TPREF ## NDArray                                                      \
@@ -214,9 +216,10 @@
     return convolve (a, c * r, ct);                                     \
   }
 
-CONV_DEFS ( , )
-CONV_DEFS (Complex, )
-CONV_DEFS (Complex, Complex)
-CONV_DEFS (Float, Float)
-CONV_DEFS (FloatComplex, Float)
-CONV_DEFS (FloatComplex, FloatComplex)
+  CONV_DEFS ( , )
+  CONV_DEFS (Complex, )
+  CONV_DEFS (Complex, Complex)
+  CONV_DEFS (Float, Float)
+  CONV_DEFS (FloatComplex, Float)
+  CONV_DEFS (FloatComplex, FloatComplex)
+}

--- a/liboctave/numeric/oct-convn.h	Tue Jul 13 23:14:33 2021 -0400
+++ b/liboctave/numeric/oct-convn.h	Wed Jul 14 00:18:49 2021 -0400
@@ -48,85 +48,277 @@
 class FloatComplexMatrix;
 class FloatComplexNDArray;
 
+// The remaining includes can be removed when the global enum
+// declaration, the convert_enum function, and the deprecated functions
+// at the end of this file are removed.
+
+#include <cstdlib>
+#include "dMatrix.h"
+#include "dNDArray.h"
+#include "CMatrix.h"
+#include "CNDArray.h"
+#include "fMatrix.h"
+#include "fNDArray.h"
+#include "fCMatrix.h"
+#include "fCNDArray.h"
+
+// FIXME: Is there any sane way to move a global enum to a namespace and
+// tag the global one as deprecated when it is used as a parameter in
+// public functions that also need to be tagged as deprecated?
+
 enum convn_type
+  {
+    convn_full,
+    convn_same,
+    convn_valid
+  };
+
+namespace octave
 {
-  convn_full,
-  convn_same,
-  convn_valid
-};
+  enum convn_type
+    {
+      convn_full,
+      convn_same,
+      convn_valid
+    };
+
+  // double real X double real
+
+  extern OCTAVE_API NDArray
+  convn (const NDArray& a, const NDArray& b, convn_type ct);
+
+  extern OCTAVE_API Matrix
+  convn (const Matrix& a, const Matrix& b, convn_type ct);
+
+  extern OCTAVE_API Matrix
+  convn (const Matrix& a, const ColumnVector& c, const RowVector& r,
+         convn_type ct);
+
+  // double complex X double real
 
-// double real X double real
+  extern OCTAVE_API ComplexNDArray
+  convn (const ComplexNDArray& a, const NDArray& b, convn_type ct);
+
+  extern OCTAVE_API ComplexMatrix
+  convn (const ComplexMatrix& a, const Matrix& b, convn_type ct);
+
+  extern OCTAVE_API ComplexMatrix
+  convn (const ComplexMatrix& a, const ColumnVector& c, const RowVector& r,
+         convn_type ct);
+
+  // double complex X double complex
+
+  extern OCTAVE_API ComplexNDArray
+  convn (const ComplexNDArray& a, const ComplexNDArray& b, convn_type ct);
+
+  extern OCTAVE_API ComplexMatrix
+  convn (const ComplexMatrix& a, const ComplexMatrix& b, convn_type ct);
+
+  extern OCTAVE_API ComplexMatrix
+  convn (const ComplexMatrix& a, const ComplexColumnVector& c,
+         const ComplexRowVector& r, convn_type ct);
+
+  // float real X float real
 
-extern OCTAVE_API NDArray
-convn (const NDArray& a, const NDArray& b, convn_type ct);
+  extern OCTAVE_API FloatNDArray
+  convn (const FloatNDArray& a, const FloatNDArray& b, convn_type ct);
+
+  extern OCTAVE_API FloatMatrix
+  convn (const FloatMatrix& a, const FloatMatrix& b, convn_type ct);
+
+  extern OCTAVE_API FloatMatrix
+  convn (const FloatMatrix& a, const FloatColumnVector& c,
+         const FloatRowVector& r, convn_type ct);
+
+  // float complex X float real
+
+  extern OCTAVE_API FloatComplexNDArray
+  convn (const FloatComplexNDArray& a, const FloatNDArray& b, convn_type ct);
+
+  extern OCTAVE_API FloatComplexMatrix
+  convn (const FloatComplexMatrix& a, const FloatMatrix& b, convn_type ct);
+
+  extern OCTAVE_API FloatComplexMatrix
+  convn (const FloatComplexMatrix& a, const FloatColumnVector& c,
+         const FloatRowVector& r, convn_type ct);
+
+  // float complex X float complex
+
+  extern OCTAVE_API FloatComplexNDArray
+  convn (const FloatComplexNDArray& a, const FloatComplexNDArray& b,
+         convn_type ct);
+
+  extern OCTAVE_API FloatComplexMatrix
+  convn (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
+         convn_type ct);
+
+  extern OCTAVE_API FloatComplexMatrix
+  convn (const FloatComplexMatrix& a, const FloatComplexColumnVector& c,
+         const FloatComplexRowVector& r, convn_type ct);
 
-extern OCTAVE_API Matrix
-convn (const Matrix& a, const Matrix& b, convn_type ct);
+  convn_type convert_enum (::convn_type ct)
+  {
+    switch (ct)
+      {
+      case ::convn_full:
+        return convn_full;
+
+      case ::convn_same:
+        return convn_same;
+
+      case ::convn_valid:
+        return convn_valid;
+
+      default:
+        abort ();
+      }
+  }
+}
 
-extern OCTAVE_API Matrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline NDArray
+convn (const NDArray& a, const NDArray& b, convn_type ct)
+{
+  return octave::convn (a, b, static_cast<octave::convn_type> (ct));
+}
+
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline Matrix
+convn (const Matrix& a, const Matrix& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
+
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline Matrix
 convn (const Matrix& a, const ColumnVector& c, const RowVector& r,
-       convn_type ct);
+       convn_type ct)
+{
+  return octave::convn (a, c, r, octave::convert_enum (ct));
+}
 
 // double complex X double real
 
-extern OCTAVE_API ComplexNDArray
-convn (const ComplexNDArray& a, const NDArray& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline ComplexNDArray
+convn (const ComplexNDArray& a, const NDArray& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API ComplexMatrix
-convn (const ComplexMatrix& a, const Matrix& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline ComplexMatrix
+convn (const ComplexMatrix& a, const Matrix& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API ComplexMatrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline ComplexMatrix
 convn (const ComplexMatrix& a, const ColumnVector& c, const RowVector& r,
-       convn_type ct);
+       convn_type ct)
+{
+  return octave::convn (a, c, r, octave::convert_enum (ct));
+}
 
 // double complex X double complex
 
-extern OCTAVE_API ComplexNDArray
-convn (const ComplexNDArray& a, const ComplexNDArray& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline ComplexNDArray
+convn (const ComplexNDArray& a, const ComplexNDArray& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API ComplexMatrix
-convn (const ComplexMatrix& a, const ComplexMatrix& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline ComplexMatrix
+convn (const ComplexMatrix& a, const ComplexMatrix& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API ComplexMatrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline ComplexMatrix
 convn (const ComplexMatrix& a, const ComplexColumnVector& c,
-       const ComplexRowVector& r, convn_type ct);
+       const ComplexRowVector& r, convn_type ct)
+{
+  return octave::convn (a, c, r, octave::convert_enum (ct));
+}
 
 // float real X float real
 
-extern OCTAVE_API FloatNDArray
-convn (const FloatNDArray& a, const FloatNDArray& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatNDArray
+convn (const FloatNDArray& a, const FloatNDArray& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API FloatMatrix
-convn (const FloatMatrix& a, const FloatMatrix& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatMatrix
+convn (const FloatMatrix& a, const FloatMatrix& b, convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API FloatMatrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatMatrix
 convn (const FloatMatrix& a, const FloatColumnVector& c,
-       const FloatRowVector& r, convn_type ct);
+       const FloatRowVector& r, convn_type ct)
+{
+  return octave::convn (a, c, r, octave::convert_enum (ct));
+}
 
 // float complex X float real
 
-extern OCTAVE_API FloatComplexNDArray
-convn (const FloatComplexNDArray& a, const FloatNDArray& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatComplexNDArray
+convn (const FloatComplexNDArray& a, const FloatNDArray& b,
+       convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API FloatComplexMatrix
-convn (const FloatComplexMatrix& a, const FloatMatrix& b, convn_type ct);
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatComplexMatrix
+convn (const FloatComplexMatrix& a, const FloatMatrix& b,
+       convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API FloatComplexMatrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatComplexMatrix
 convn (const FloatComplexMatrix& a, const FloatColumnVector& c,
-       const FloatRowVector& r, convn_type ct);
+       const FloatRowVector& r, convn_type ct)
+{
+  return octave::convn (a, c, r, octave::convert_enum (ct));
+}
 
 // float complex X float complex
 
-extern OCTAVE_API FloatComplexNDArray
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatComplexNDArray
 convn (const FloatComplexNDArray& a, const FloatComplexNDArray& b,
-       convn_type ct);
+       convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API FloatComplexMatrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatComplexMatrix
 convn (const FloatComplexMatrix& a, const FloatComplexMatrix& b,
-       convn_type ct);
+       convn_type ct)
+{
+  return octave::convn (a, b, octave::convert_enum (ct));
+}
 
-extern OCTAVE_API FloatComplexMatrix
+OCTAVE_DEPRECATED (7, "use 'octave::convn' instead")
+inline FloatComplexMatrix
 convn (const FloatComplexMatrix& a, const FloatComplexColumnVector& c,
-       const FloatComplexRowVector& r, convn_type ct);
+       const FloatComplexRowVector& r, convn_type ct)
+{
+  return octave::convn (a, c, r, octave::convert_enum (ct));
+}
 
 #endif