Mercurial > hg > octave-lyh

changeset 7193:cbdee3da62bd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2007-11-26 22:20:25 by dbateman]
author dbateman
date Mon, 26 Nov 2007 22:20:25 +0000 (2007-11-26)
parents 10b8361ff085
children a927a2871a93
files src/ChangeLog src/ov-base.cc src/ov-base.h src/ov-bool-sparse.cc src/ov-cx-sparse.cc src/ov-re-sparse.cc
diffstat 6 files changed, 107 insertions(+), 49 deletions(-) [+]
line wrap: on
line diff
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,17 @@
 2007-11-26  David Bateman  <dbateman@free.fr>
 
+	* ov-base.cc (Vsparse_auto_mutate, Fsparse_auto_mutate): New
+	internal variable and built-in function to set it.
+	* ov-base.h (extern bool Vsparse_auto_mutate): Export internal
+	variable to other functions.
+	* ov-re-sparse.cc (octave_sparse_matrix::try_narrowing_conversion
+	(void)), ov-cx-sparse.cc 
+	(octave_sparse_complex_matrix::try_narrowing_conversion (void)), 
+	ov-bool-sparse.cc
+	(octave_sparse_bool_matrix::try_narrowing_conversion (void)):
+	Use Vsparse_auto_mutate flag to determine whether to convert
+	sparse matrices to full matrices if that saves space.
+
 	* DLD-FUNCTIONS/minmax.cc (MINMAX_DOUBLE_BODY): New version of
 	MINMAX_BODY macro without the initialization.
 	(MINMAX_INT_BODY): Macro for min/max for the integer types
--- a/src/ov-base.cc
+++ b/src/ov-base.cc
@@ -65,6 +65,10 @@
 // semicolon has been appended to each statement).
 static bool Vsilent_functions = false;
 
+// TRUE means to perform automatic sparse to real mutation if there
+// is memory to be saved
+bool Vsparse_auto_mutate = false;
+
 octave_value
 octave_base_value::squeeze (void) const
 {
@@ -1131,6 +1135,30 @@
   return SET_INTERNAL_VARIABLE (silent_functions);
 }
 
+DEFUN (sparse_auto_mutate, args, nargout,
+  "-*- texinfo -*-\n\
+@deftypefn {Built-in Function} {@var{val} =} sparse_auto_mutate ()\n\
+@deftypefnx {Built-in Function} {@var{old_val} =} sparse_auto_mutate (@var{new_val})\n\
+Query or set the internal variable that controls whether Octave will\n\
+automatically mutate sparse matrices to real matrices to save memory.\n\
+For example,\n\
+\n\
+@example\n\
+s = speye(3);\n\
+sparse_auto_mutate (false)\n\
+s (:, 1) = 1;\n\
+typeinfo (s)\n\
+@result{} sparse matrix\n\
+sparse_auto_mutate (true)\n\
+s (1, :) = 1;\n\
+typeinfo (s)\n\
+@result{} matrix\n\
+@end example\n\
+@end deftypefn")
+{
+  return SET_INTERNAL_VARIABLE (sparse_auto_mutate);
+}
+
 /*
 ;;; Local Variables: ***
 ;;; mode: C++ ***
--- a/src/ov-base.h
+++ b/src/ov-base.h
@@ -487,6 +487,10 @@
   DECLARE_OV_BASE_TYPEID_FUNCTIONS_AND_DATA
 };
 
+// TRUE means to perform automatic sparse to real mutation if there
+// is memory to be saved
+extern bool Vsparse_auto_mutate;
+
 #endif
 
 /*
--- a/src/ov-bool-sparse.cc
+++ b/src/ov-bool-sparse.cc
@@ -69,20 +69,23 @@
 {
   octave_base_value *retval = 0;
 
-  // Don't use numel, since it can overflow for very large matrices
-  // Note that for the second test, this means it becomes approximative
-  // since it involves a cast to double to avoid issues of overflow
-  if (matrix.rows () == 1 && matrix.cols () == 1)
+  if (Vsparse_auto_mutate)
     {
-      // Const copy of the matrix, so the right version of () operator used
-      const SparseBoolMatrix tmp (matrix);
+      // Don't use numel, since it can overflow for very large matrices
+      // Note that for the second test, this means it becomes approximative
+      // since it involves a cast to double to avoid issues of overflow
+      if (matrix.rows () == 1 && matrix.cols () == 1)
+	{
+	  // Const copy of the matrix, so the right version of () operator used
+	  const SparseBoolMatrix tmp (matrix);
 
-      retval = new octave_bool (tmp (0));
+	  retval = new octave_bool (tmp (0));
+	}
+      else if (matrix.cols () > 0 && matrix.rows () > 0 && 
+	       double (matrix.byte_size ()) > double (matrix.rows ()) *
+	       double (matrix.cols ()) * sizeof (bool))
+	retval = new octave_bool_matrix (matrix.matrix_value ());
     }
-  else if (matrix.cols () > 0 && matrix.rows () > 0 && 
-	   double (matrix.byte_size ()) > double (matrix.rows ()) *
-	   double (matrix.cols ()) * sizeof (bool))
-    retval = new octave_bool_matrix (matrix.matrix_value ());
 
   return retval;
 }
--- a/src/ov-cx-sparse.cc
+++ b/src/ov-cx-sparse.cc
@@ -54,37 +54,45 @@
 {
   octave_base_value *retval = 0;
 
-  int nr = matrix.rows ();
-  int nc = matrix.cols ();
+  if (Vsparse_auto_mutate)
+    {
+      int nr = matrix.rows ();
+      int nc = matrix.cols ();
 
-  // Don't use numel, since it can overflow for very large matrices
-  // Note that for the tests on matrix size, they become approximative
-  // since they involves a cast to double to avoid issues of overflow
-  if (matrix.rows () == 1 && matrix.cols () == 1)
-    {
-      // Const copy of the matrix, so the right version of () operator used
-      const SparseComplexMatrix tmp (matrix);
+      // Don't use numel, since it can overflow for very large matrices
+      // Note that for the tests on matrix size, they become approximative
+      // since they involves a cast to double to avoid issues of overflow
+      if (matrix.rows () == 1 && matrix.cols () == 1)
+	{
+	  // Const copy of the matrix, so the right version of () operator used
+	  const SparseComplexMatrix tmp (matrix);
 
-      Complex c = tmp (0, 0);
+	  Complex c = tmp (0, 0);
 
-      if (imag (c) == 0.0)
-	retval = new octave_scalar (std::real (c));
-      else
-	retval = new octave_complex (c);
+	  if (imag (c) == 0.0)
+	    retval = new octave_scalar (std::real (c));
+	  else
+	    retval = new octave_complex (c);
+	}
+      else if (nr == 0 || nc == 0)
+	retval = new octave_matrix (Matrix (nr, nc));
+      else if (matrix.all_elements_are_real ())
+	if (matrix.cols () > 0 && matrix.rows () > 0 && 
+	    double (matrix.byte_size ()) > double (matrix.rows ()) *
+	    double (matrix.cols ()) * sizeof (double))
+	  retval = new octave_matrix (::real (matrix.matrix_value ()));
+	else
+	  retval = new octave_sparse_matrix (::real (matrix));
+      else if (matrix.cols () > 0 && matrix.rows () > 0 && 
+	       double (matrix.byte_size ()) > double (matrix.rows ()) *
+	       double (matrix.cols ()) * sizeof (Complex))
+	retval = new octave_complex_matrix (matrix.matrix_value ());
     }
-  else if (nr == 0 || nc == 0)
-    retval = new octave_matrix (Matrix (nr, nc));
-  else if (matrix.all_elements_are_real ())
-    if (matrix.cols () > 0 && matrix.rows () > 0 && 
-	double (matrix.byte_size ()) > double (matrix.rows ()) *
-	double (matrix.cols ()) * sizeof (double))
-      retval = new octave_matrix (::real (matrix.matrix_value ()));
-    else
-      retval = new octave_sparse_matrix (::real (matrix));
-  else if (matrix.cols () > 0 && matrix.rows () > 0 && 
-	   double (matrix.byte_size ()) > double (matrix.rows ()) *
-	   double (matrix.cols ()) * sizeof (Complex))
-    retval = new octave_complex_matrix (matrix.matrix_value ());
+  else
+    {
+      if (matrix.all_elements_are_real ())
+	retval = new octave_sparse_matrix (::real (matrix));
+    }
     
   return retval;
 }
--- a/src/ov-re-sparse.cc
+++ b/src/ov-re-sparse.cc
@@ -67,20 +67,23 @@
 {
   octave_base_value *retval = 0;
 
-  // Don't use numel, since it can overflow for very large matrices
-  // Note that for the second test, this means it becomes approximative
-  // since it involves a cast to double to avoid issues of overflow
-  if (matrix.rows () == 1 && matrix.cols () == 1)
+  if (Vsparse_auto_mutate)
     {
-      // Const copy of the matrix, so the right version of () operator used
-      const SparseMatrix tmp (matrix);
+      // Don't use numel, since it can overflow for very large matrices
+      // Note that for the second test, this means it becomes approximative
+      // since it involves a cast to double to avoid issues of overflow
+      if (matrix.rows () == 1 && matrix.cols () == 1)
+	{
+	  // Const copy of the matrix, so the right version of () operator used
+	  const SparseMatrix tmp (matrix);
 
-      retval = new octave_scalar (tmp (0));
+	  retval = new octave_scalar (tmp (0));
+	}
+      else if (matrix.cols () > 0 && matrix.rows () > 0 && 
+	       double (matrix.byte_size ()) > double (matrix.rows ()) *
+	       double (matrix.cols ()) * sizeof (double))
+	retval = new octave_matrix (matrix.matrix_value ());
     }
-  else if (matrix.cols () > 0 && matrix.rows () > 0 && 
-	   double (matrix.byte_size ()) > double (matrix.rows ()) *
-	   double (matrix.cols ()) * sizeof (double))
-    retval = new octave_matrix (matrix.matrix_value ());
 
   return retval;
 }