decent printing: refactoring xxx_to_string()

Author: counterclocker

cysparse/sparse/ll_mat_matrices/ll_mat.cpx

@@ -19,6 +19,7 @@ from cysparse.sparse.csr_mat_matrices.csr_mat_@index@_@type@ cimport MakeCSRSpar
 from cysparse.sparse.csc_mat_matrices.csc_mat_@index@_@type@ cimport MakeCSCSparseMatrix_@index@_@type@
 
 from cysparse.sparse.sparse_utils.generic.generate_indices_@index@ cimport create_c_array_indices_from_python_object_@index@
+from cysparse.sparse.sparse_utils.generic.print_@type@ cimport element_to_string_@type@, empty_to_string_@type@
 
 ########################################################################################################################
 # CySparse include
@@ -2392,7 +2393,7 @@ YOU HAVE TO CAST YOUR NEW TYPE HERE
     ####################################################################################################################
     # String representations
     ####################################################################################################################
-    def at_to_string(self, @index@ i, @index@ j, @index@ cell_width=10):
+    def at_to_string(self, @index@ i, @index@ j, int cell_width=10):
         """
         Return a string with a given element if it exists or an "empty" string.
 
@@ -2409,67 +2410,15 @@ YOU HAVE TO CAST YOUR NEW TYPE HERE
             next_col = self.col[k]
             if next_col >= j:
                 if next_col == j:
-                    v = self.val[k]
-{% if type in integer_list %}
-                    exp = log(fabs(<FLOAT64_t> self.val[k]))
-{% elif type == 'FLOAT32_t' %}
-                    exp = log(fabsf(self.val[k]))
-{% elif type == 'FLOAT64_t' %}
-                    exp = log(fabs(self.val[k]))
-{% elif type == 'FLOAT128_t' %}
-                    exp = log(fabsl(self.val[k]))
-{% elif type == 'COMPLEX64_t' %}
-                    exp = log(cabsf(self.val[k]))
-{% elif type == 'COMPLEX128_t' %}
-                    exp = log(cabs(self.val[k]))
-{% elif type == 'COMPLEX256_t' %}
-                    exp = log(cabsl(self.val[k]))
-{% else %}
-YOU HAVE TO CAST YOUR NEW TYPE HERE
-{% endif %}
-                    if abs(exp) <= 4:
-                        if exp < 0:
-{% if type == 'COMPLEX64_t' %}
-                            return ("%9.6f" % crealf(v)).ljust(cell_width) + '+' + ("%9.6fj" % cimagf(v)).ljust(cell_width)
-{% elif type == 'COMPLEX128_t' %}
-                            return ("%9.6f" % creal(v)).ljust(cell_width) + '+' + ("%9.6fj" % cimag(v)).ljust(cell_width)
-{% elif type == 'COMPLEX256_t' %}
-                            return ("%9.6f" % creall(v)).ljust(cell_width) + '+' + ("%9.6fj" % cimagl(v)).ljust(cell_width)
-{% else %}
-                            return ("%9.6f" % v).ljust(cell_width)
-{% endif %}
-
-                        else:
-{% if type == 'COMPLEX64_t' %}
-                            return ("%9.*f" % (6,crealf(v))).ljust(cell_width) + '+' + ("%9.*fj" % (6,cimagf(v))).ljust(cell_width)
-{% elif type == 'COMPLEX128_t' %}
-                            return ("%9.*f" % (6,creal(v))).ljust(cell_width) + '+' + ("%9.*fj" % (6,cimag(v))).ljust(cell_width)
-{% elif type == 'COMPLEX256_t' %}
-                            return ("%9.*f" % (6,creall(v))).ljust(cell_width) + '+' + ("%9.*fj" % (6,cimagl(v))).ljust(cell_width)
-{% else %}
-                            return ("%9.*f" % (6,v)).ljust(cell_width)
-{% endif %}
-
-                    else:
-{% if type == 'COMPLEX64_t' %}
-                        return ("%9.2e" % crealf(v)).ljust(cell_width) + '+' + ("%9.2ej" % cimagf(v)).ljust(cell_width)
-{% elif type == 'COMPLEX128_t' %}
-                        return ("%9.2e" % creal(v)).ljust(cell_width) + '+' + ("%9.2ej" % cimag(v)).ljust(cell_width)
-{% elif type == 'COMPLEX256_t' %}
-                        return ("%9.2e" % creall(v)).ljust(cell_width) + '+' + ("%9.2ej" % cimagl(v)).ljust(cell_width)
-{% else %}
-                        return ("%9.2e" % v).ljust(cell_width)
-{% endif %}
-
+                    #v = self.val[k]
+                    return element_to_string_@type@(self.val[k], cell_width=cell_width)
                 else:  # value not found
                     break
 
             k = self.link[k]
-{% if type in complex_list %}
-        return "---".center(cell_width) + ' ' + "---".center(cell_width)
-{% else %}
-        return "---".center(cell_width)
-{% endif %}
+
+        # element not found -> return empty cell
+        return empty_to_string_@type@(cell_width=cell_width)
 
     def print_to(self, OUT, width=9, print_big_matrices=False, transposed=False):
         """

cysparse/sparse/ll_mat_matrices/ll_mat_INT32_t_COMPLEX128_t.c

@@ -19,6 +19,7 @@ from cysparse.sparse.csr_mat_matrices.csr_mat_INT32_t_COMPLEX128_t cimport MakeC
 from cysparse.sparse.csc_mat_matrices.csc_mat_INT32_t_COMPLEX128_t cimport MakeCSCSparseMatrix_INT32_t_COMPLEX128_t
 
 from cysparse.sparse.sparse_utils.generic.generate_indices_INT32_t cimport create_c_array_indices_from_python_object_INT32_t
+from cysparse.sparse.sparse_utils.generic.print_COMPLEX128_t cimport element_to_string_COMPLEX128_t, empty_to_string_COMPLEX128_t
 
 ########################################################################################################################
 # CySparse include
@@ -2218,7 +2219,7 @@ cdef class LLSparseMatrix_INT32_t_COMPLEX128_t(MutableSparseMatrix_INT32_t_COMPL
     ####################################################################################################################
     # String representations
     ####################################################################################################################
-    def at_to_string(self, INT32_t i, INT32_t j, INT32_t cell_width=10):
+    def at_to_string(self, INT32_t i, INT32_t j, int cell_width=10):
         """
         Return a string with a given element if it exists or an "empty" string.
 
@@ -2235,33 +2236,15 @@ cdef class LLSparseMatrix_INT32_t_COMPLEX128_t(MutableSparseMatrix_INT32_t_COMPL
             next_col = self.col[k]
             if next_col >= j:
                 if next_col == j:
-                    v = self.val[k]
-
-                    exp = log(cabs(self.val[k]))
-
-                    if abs(exp) <= 4:
-                        if exp < 0:
-
-                            return ("%9.6f" % creal(v)).ljust(cell_width) + '+' + ("%9.6fj" % cimag(v)).ljust(cell_width)
-
-
-                        else:
-
-                            return ("%9.*f" % (6,creal(v))).ljust(cell_width) + '+' + ("%9.*fj" % (6,cimag(v))).ljust(cell_width)
-
-
-                    else:
-
-                        return ("%9.2e" % creal(v)).ljust(cell_width) + '+' + ("%9.2ej" % cimag(v)).ljust(cell_width)
-
-
+                    #v = self.val[k]
+                    return element_to_string_COMPLEX128_t(self.val[k], cell_width=cell_width)
                 else:  # value not found
                     break
 
             k = self.link[k]
 
-        return "---".center(cell_width) + ' ' + "---".center(cell_width)
-
+        # element not found -> return empty cell
+        return empty_to_string_COMPLEX128_t(cell_width=cell_width)
 
     def print_to(self, OUT, width=9, print_big_matrices=False, transposed=False):
         """