diff libinterp/corefcn/xnorm.cc @ 29874:92662b17ef7e

move liboctave xnorm functions inside octave namespace * oct-norm.h (xnorm, xfrobnorm, xcolnorms, xrownorms): Move inside octave namespace. Provide deprecated wrappers for old names. Change uses where needed. * oct-norm.cc: Move templates inside octave namespace. Use octave:: namespace tag where needed. Cast second arg for norm from int to appropriate floating point type where needed. Eliminate OCTAVE_API and extern from definitions of xnorm functions.
author John W. Eaton <jwe@octave.org>
date Tue, 13 Jul 2021 22:56:23 -0400
parents 0a5b15007766
children b260322f6730
line wrap: on
line diff
--- a/libinterp/corefcn/xnorm.cc	Tue Jul 13 15:30:07 2021 -0400
+++ b/libinterp/corefcn/xnorm.cc	Tue Jul 13 22:56:23 2021 -0400
@@ -50,41 +50,41 @@
   else if (isvector)
     {
       if (isfloat & iscomplex)
-        retval = xnorm (x.float_complex_column_vector_value (),
-                        p.float_value ());
+        retval = octave::xnorm (x.float_complex_column_vector_value (),
+                                p.float_value ());
       else if (isfloat)
-        retval = xnorm (x.float_column_vector_value (),
-                        p.float_value ());
+        retval = octave::xnorm (x.float_column_vector_value (),
+                                p.float_value ());
       else if (iscomplex)
-        retval = xnorm (x.complex_column_vector_value (),
-                        p.double_value ());
+        retval = octave::xnorm (x.complex_column_vector_value (),
+                                p.double_value ());
       else
-        retval = xnorm (x.column_vector_value (),
-                        p.double_value ());
+        retval = octave::xnorm (x.column_vector_value (),
+                                p.double_value ());
     }
   else if (issparse)
     {
       if (iscomplex)
-        retval = xnorm (x.sparse_complex_matrix_value (),
-                        p.double_value ());
+        retval = octave::xnorm (x.sparse_complex_matrix_value (),
+                                p.double_value ());
       else
-        retval = xnorm (x.sparse_matrix_value (),
-                        p.double_value ());
+        retval = octave::xnorm (x.sparse_matrix_value (),
+                                p.double_value ());
     }
   else
     {
       if (isfloat & iscomplex)
-        retval = xnorm (x.float_complex_matrix_value (),
-                        p.float_value ());
+        retval = octave::xnorm (x.float_complex_matrix_value (),
+                                p.float_value ());
       else if (isfloat)
-        retval = xnorm (x.float_matrix_value (),
-                        p.float_value ());
+        retval = octave::xnorm (x.float_matrix_value (),
+                                p.float_value ());
       else if (iscomplex)
-        retval = xnorm (x.complex_matrix_value (),
-                        p.double_value ());
+        retval = octave::xnorm (x.complex_matrix_value (),
+                                p.double_value ());
       else
-        retval = xnorm (x.matrix_value (),
-                        p.double_value ());
+        retval = octave::xnorm (x.matrix_value (),
+                                p.double_value ());
     }
 
   return retval;
@@ -104,26 +104,26 @@
   if (issparse)
     {
       if (iscomplex)
-        retval = xcolnorms (x.sparse_complex_matrix_value (),
-                            p.double_value ());
+        retval = octave::xcolnorms (x.sparse_complex_matrix_value (),
+                                    p.double_value ());
       else
-        retval = xcolnorms (x.sparse_matrix_value (),
-                            p.double_value ());
+        retval = octave::xcolnorms (x.sparse_matrix_value (),
+                                    p.double_value ());
     }
   else
     {
       if (isfloat & iscomplex)
-        retval = xcolnorms (x.float_complex_matrix_value (),
-                            p.float_value ());
+        retval = octave::xcolnorms (x.float_complex_matrix_value (),
+                                    p.float_value ());
       else if (isfloat)
-        retval = xcolnorms (x.float_matrix_value (),
-                            p.float_value ());
+        retval = octave::xcolnorms (x.float_matrix_value (),
+                                    p.float_value ());
       else if (iscomplex)
-        retval = xcolnorms (x.complex_matrix_value (),
-                            p.double_value ());
+        retval = octave::xcolnorms (x.complex_matrix_value (),
+                                    p.double_value ());
       else
-        retval = xcolnorms (x.matrix_value (),
-                            p.double_value ());
+        retval = octave::xcolnorms (x.matrix_value (),
+                                    p.double_value ());
     }
 
   return retval;
@@ -143,26 +143,26 @@
   if (issparse)
     {
       if (iscomplex)
-        retval = xrownorms (x.sparse_complex_matrix_value (),
-                            p.double_value ());
+        retval = octave::xrownorms (x.sparse_complex_matrix_value (),
+                                    p.double_value ());
       else
-        retval = xrownorms (x.sparse_matrix_value (),
-                            p.double_value ());
+        retval = octave::xrownorms (x.sparse_matrix_value (),
+                                    p.double_value ());
     }
   else
     {
       if (isfloat & iscomplex)
-        retval = xrownorms (x.float_complex_matrix_value (),
-                            p.float_value ());
+        retval = octave::xrownorms (x.float_complex_matrix_value (),
+                                    p.float_value ());
       else if (isfloat)
-        retval = xrownorms (x.float_matrix_value (),
-                            p.float_value ());
+        retval = octave::xrownorms (x.float_matrix_value (),
+                                    p.float_value ());
       else if (iscomplex)
-        retval = xrownorms (x.complex_matrix_value (),
-                            p.double_value ());
+        retval = octave::xrownorms (x.complex_matrix_value (),
+                                    p.double_value ());
       else
-        retval = xrownorms (x.matrix_value (),
-                            p.double_value ());
+        retval = octave::xrownorms (x.matrix_value (),
+                                    p.double_value ());
     }
 
   return retval;
@@ -182,20 +182,20 @@
   if (issparse)
     {
       if (iscomplex)
-        retval = xfrobnorm (x.sparse_complex_matrix_value ());
+        retval = octave::xfrobnorm (x.sparse_complex_matrix_value ());
       else
-        retval = xfrobnorm (x.sparse_matrix_value ());
+        retval = octave::xfrobnorm (x.sparse_matrix_value ());
     }
   else
     {
       if (isfloat & iscomplex)
-        retval = xfrobnorm (x.float_complex_matrix_value ());
+        retval = octave::xfrobnorm (x.float_complex_matrix_value ());
       else if (isfloat)
-        retval = xfrobnorm (x.float_matrix_value ());
+        retval = octave::xfrobnorm (x.float_matrix_value ());
       else if (iscomplex)
-        retval = xfrobnorm (x.complex_matrix_value ());
+        retval = octave::xfrobnorm (x.complex_matrix_value ());
       else
-        retval = xfrobnorm (x.matrix_value ());
+        retval = octave::xfrobnorm (x.matrix_value ());
     }
 
   return retval;