--- a/liboctave/dSparse.cc	Thu Feb 11 12:16:43 2010 -0500
+++ b/liboctave/dSparse.cc	Thu Feb 11 12:23:32 2010 -0500
@@ -67,66 +67,66 @@
 {
   F77_RET_T
   F77_FUNC (dgbtrf, DGBTRF) (const octave_idx_type&, const octave_idx_type&,
-			     const octave_idx_type&, const octave_idx_type&,
-			     double*, const octave_idx_type&,
-			     octave_idx_type*, octave_idx_type&);
+                             const octave_idx_type&, const octave_idx_type&,
+                             double*, const octave_idx_type&,
+                             octave_idx_type*, octave_idx_type&);
 
   F77_RET_T
   F77_FUNC (dgbtrs, DGBTRS) (F77_CONST_CHAR_ARG_DECL, const octave_idx_type&,
-			     const octave_idx_type&, const octave_idx_type&, const octave_idx_type&, 
-			     const double*, const octave_idx_type&,
-			     const octave_idx_type*, double*, const octave_idx_type&, octave_idx_type&
-			     F77_CHAR_ARG_LEN_DECL);
+                             const octave_idx_type&, const octave_idx_type&, const octave_idx_type&, 
+                             const double*, const octave_idx_type&,
+                             const octave_idx_type*, double*, const octave_idx_type&, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL);
 
   F77_RET_T
   F77_FUNC (dgbcon, DGBCON) (F77_CONST_CHAR_ARG_DECL, const octave_idx_type&, 
-			     const octave_idx_type&, const octave_idx_type&, double*, 
-			     const octave_idx_type&, const octave_idx_type*, const double&, 
-			     double&, double*, octave_idx_type*, octave_idx_type&
-			     F77_CHAR_ARG_LEN_DECL);
+                             const octave_idx_type&, const octave_idx_type&, double*, 
+                             const octave_idx_type&, const octave_idx_type*, const double&, 
+                             double&, double*, octave_idx_type*, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL);
 
   F77_RET_T
   F77_FUNC (dpbtrf, DPBTRF) (F77_CONST_CHAR_ARG_DECL, const octave_idx_type&, 
-			     const octave_idx_type&, double*, const octave_idx_type&, octave_idx_type&
-			     F77_CHAR_ARG_LEN_DECL);
+                             const octave_idx_type&, double*, const octave_idx_type&, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL);
 
   F77_RET_T
   F77_FUNC (dpbtrs, DPBTRS) (F77_CONST_CHAR_ARG_DECL, const octave_idx_type&, 
-			     const octave_idx_type&, const octave_idx_type&, double*, const octave_idx_type&, 
-			     double*, const octave_idx_type&, octave_idx_type&
-			     F77_CHAR_ARG_LEN_DECL);
+                             const octave_idx_type&, const octave_idx_type&, double*, const octave_idx_type&, 
+                             double*, const octave_idx_type&, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL);
 
   F77_RET_T
   F77_FUNC (dpbcon, DPBCON) (F77_CONST_CHAR_ARG_DECL, const octave_idx_type&, 
-			     const octave_idx_type&, double*, const octave_idx_type&, 
-			     const double&, double&, double*, octave_idx_type*, octave_idx_type&
-			     F77_CHAR_ARG_LEN_DECL);
+                             const octave_idx_type&, double*, const octave_idx_type&, 
+                             const double&, double&, double*, octave_idx_type*, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL);
   F77_RET_T
   F77_FUNC (dptsv, DPTSV) (const octave_idx_type&, const octave_idx_type&, double*, double*,
-			   double*, const octave_idx_type&, octave_idx_type&);
+                           double*, const octave_idx_type&, octave_idx_type&);
 
   F77_RET_T
   F77_FUNC (dgtsv, DGTSV) (const octave_idx_type&, const octave_idx_type&, double*, double*,
-			   double*, double*, const octave_idx_type&, octave_idx_type&);
+                           double*, double*, const octave_idx_type&, octave_idx_type&);
 
   F77_RET_T
   F77_FUNC (dgttrf, DGTTRF) (const octave_idx_type&, double*, double*, double*, double*,
-			     octave_idx_type*, octave_idx_type&);
+                             octave_idx_type*, octave_idx_type&);
 
   F77_RET_T
   F77_FUNC (dgttrs, DGTTRS) (F77_CONST_CHAR_ARG_DECL, const octave_idx_type&,
-			     const octave_idx_type&, const double*, const double*,
-			     const double*, const double*, const octave_idx_type*,
-			     double *, const octave_idx_type&, octave_idx_type&
-			     F77_CHAR_ARG_LEN_DECL);
+                             const octave_idx_type&, const double*, const double*,
+                             const double*, const double*, const octave_idx_type*,
+                             double *, const octave_idx_type&, octave_idx_type&
+                             F77_CHAR_ARG_LEN_DECL);
 
   F77_RET_T
   F77_FUNC (zptsv, ZPTSV) (const octave_idx_type&, const octave_idx_type&, double*, Complex*,
-			   Complex*, const octave_idx_type&, octave_idx_type&);
+                           Complex*, const octave_idx_type&, octave_idx_type&);
 
   F77_RET_T
   F77_FUNC (zgtsv, ZGTSV) (const octave_idx_type&, const octave_idx_type&, Complex*, Complex*,
-			   Complex*, Complex*, const octave_idx_type&, octave_idx_type&);
+                           Complex*, Complex*, const octave_idx_type&, octave_idx_type&);
 
 }
 
@@ -202,7 +202,7 @@
 
   for (octave_idx_type i = 0; i < nc + 1; i++)
     if (cidx(i) != a.cidx(i))
-	return false;
+        return false;
 
   for (octave_idx_type i = 0; i < nz; i++)
     if (data(i) != a.data(i) || ridx(i) != a.ridx(i))
@@ -226,30 +226,30 @@
   if (nr == nc && nr > 0)
     {
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      octave_idx_type ri = ridx(i);
-
-	      if (ri != j)
-		{
-		  bool found = false;
-
-		  for (octave_idx_type k = cidx(ri); k < cidx(ri+1); k++)
-		    {
-		      if (ridx(k) == j)
-			{
-			  if (data(i) == data(k))
-			    found = true;
-			  break;
-			}
-		    }
-
-		  if (! found)
-		    return false;
-		}
-	    }
-	}
+        {
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              octave_idx_type ri = ridx(i);
+
+              if (ri != j)
+                {
+                  bool found = false;
+
+                  for (octave_idx_type k = cidx(ri); k < cidx(ri+1); k++)
+                    {
+                      if (ridx(k) == j)
+                        {
+                          if (data(i) == data(k))
+                            found = true;
+                          break;
+                        }
+                    }
+
+                  if (! found)
+                    return false;
+                }
+            }
+        }
 
       return true;
     }
@@ -298,99 +298,99 @@
       idx_arg.clear (1, nc);
       octave_idx_type nel = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  double tmp_max = octave_NaN;
-	  octave_idx_type idx_j = 0;
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      if (ridx(i) != idx_j)
-		break;
-	      else
-		idx_j++;
-	    }
-
-	  if (idx_j != nr)
-	    tmp_max = 0.;
-
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      double tmp = data (i);
-
-	      if (xisnan (tmp))
-		continue;
-	      else if (xisnan (tmp_max) || tmp > tmp_max)
-		{
-		  idx_j = ridx (i);
-		  tmp_max = tmp;
-		}
-
-	    }
-
- 	  idx_arg.elem (j) = xisnan (tmp_max) ? 0 : idx_j;
-	  if (tmp_max != 0.)
-	    nel++;
-	}
+        {
+          double tmp_max = octave_NaN;
+          octave_idx_type idx_j = 0;
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              if (ridx(i) != idx_j)
+                break;
+              else
+                idx_j++;
+            }
+
+          if (idx_j != nr)
+            tmp_max = 0.;
+
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              double tmp = data (i);
+
+              if (xisnan (tmp))
+                continue;
+              else if (xisnan (tmp_max) || tmp > tmp_max)
+                {
+                  idx_j = ridx (i);
+                  tmp_max = tmp;
+                }
+
+            }
+
+          idx_arg.elem (j) = xisnan (tmp_max) ? 0 : idx_j;
+          if (tmp_max != 0.)
+            nel++;
+        }
 
       result = SparseMatrix (1, nc, nel);
 
       octave_idx_type ii = 0;
       result.xcidx (0) = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  double tmp = elem (idx_arg(j), j);
-	  if (tmp != 0.)
-	    {
-	      result.xdata (ii) = tmp;
-	      result.xridx (ii++) = 0;
-	    }
-	  result.xcidx (j+1) = ii;
-
-	}
+        {
+          double tmp = elem (idx_arg(j), j);
+          if (tmp != 0.)
+            {
+              result.xdata (ii) = tmp;
+              result.xridx (ii++) = 0;
+            }
+          result.xcidx (j+1) = ii;
+
+        }
     }
   else
     {
       idx_arg.resize_fill (nr, 1, 0);
 
       for (octave_idx_type i = cidx(0); i < cidx(1); i++)
-	idx_arg.elem(ridx(i)) = -1;
+        idx_arg.elem(ridx(i)) = -1;
 
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = 0; i < nr; i++)
-	  {
-	    if (idx_arg.elem(i) != -1)
-	      continue;
-	    bool found = false;
-	    for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
-	      if (ridx(k) == i)
-		{
-		  found = true;
-		  break;
-		}
-	    
-	    if (!found)
-	      idx_arg.elem(i) = j;
-
-	  }
+        for (octave_idx_type i = 0; i < nr; i++)
+          {
+            if (idx_arg.elem(i) != -1)
+              continue;
+            bool found = false;
+            for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
+              if (ridx(k) == i)
+                {
+                  found = true;
+                  break;
+                }
+            
+            if (!found)
+              idx_arg.elem(i) = j;
+
+          }
 
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      octave_idx_type ir = ridx (i);
-	      octave_idx_type ix = idx_arg.elem (ir);
-	      double tmp = data (i);
-
-	      if (xisnan (tmp))
-		continue;
-	      else if (ix == -1 || tmp > elem (ir, ix))
-		idx_arg.elem (ir) = j;
-	    }
-	}
+        {
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              octave_idx_type ir = ridx (i);
+              octave_idx_type ix = idx_arg.elem (ir);
+              double tmp = data (i);
+
+              if (xisnan (tmp))
+                continue;
+              else if (ix == -1 || tmp > elem (ir, ix))
+                idx_arg.elem (ir) = j;
+            }
+        }
 
       octave_idx_type nel = 0;
       for (octave_idx_type j = 0; j < nr; j++)
-	if (idx_arg.elem(j) == -1 || elem (j, idx_arg.elem (j)) != 0.)
-	  nel++;
+        if (idx_arg.elem(j) == -1 || elem (j, idx_arg.elem (j)) != 0.)
+          nel++;
 
       result = SparseMatrix (nr, 1, nel);
 
@@ -398,23 +398,23 @@
       result.xcidx (0) = 0;
       result.xcidx (1) = nel;
       for (octave_idx_type j = 0; j < nr; j++)
-	{
-	  if (idx_arg(j) == -1)
-	    {
-	      idx_arg(j) = 0;
-	      result.xdata (ii) = octave_NaN;
-	      result.xridx (ii++) = j;
-	    }
-	  else
-	    {
-	      double tmp = elem (j, idx_arg(j));
-	      if (tmp != 0.)
-		{
-		  result.xdata (ii) = tmp;
-		  result.xridx (ii++) = j;
-		}
-	    }
-	}
+        {
+          if (idx_arg(j) == -1)
+            {
+              idx_arg(j) = 0;
+              result.xdata (ii) = octave_NaN;
+              result.xridx (ii++) = j;
+            }
+          else
+            {
+              double tmp = elem (j, idx_arg(j));
+              if (tmp != 0.)
+                {
+                  result.xdata (ii) = tmp;
+                  result.xridx (ii++) = j;
+                }
+            }
+        }
     }
 
   return result;
@@ -447,99 +447,99 @@
       idx_arg.clear (1, nc);
       octave_idx_type nel = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  double tmp_min = octave_NaN;
-	  octave_idx_type idx_j = 0;
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      if (ridx(i) != idx_j)
-		break;
-	      else
-		idx_j++;
-	    }
-
-	  if (idx_j != nr)
-	    tmp_min = 0.;
-
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      double tmp = data (i);
-
-	      if (xisnan (tmp))
-		continue;
-	      else if (xisnan (tmp_min) || tmp < tmp_min)
-		{
-		  idx_j = ridx (i);
-		  tmp_min = tmp;
-		}
-
-	    }
-
- 	  idx_arg.elem (j) = xisnan (tmp_min) ? 0 : idx_j;
-	  if (tmp_min != 0.)
-	    nel++;
-	}
+        {
+          double tmp_min = octave_NaN;
+          octave_idx_type idx_j = 0;
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              if (ridx(i) != idx_j)
+                break;
+              else
+                idx_j++;
+            }
+
+          if (idx_j != nr)
+            tmp_min = 0.;
+
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              double tmp = data (i);
+
+              if (xisnan (tmp))
+                continue;
+              else if (xisnan (tmp_min) || tmp < tmp_min)
+                {
+                  idx_j = ridx (i);
+                  tmp_min = tmp;
+                }
+
+            }
+
+          idx_arg.elem (j) = xisnan (tmp_min) ? 0 : idx_j;
+          if (tmp_min != 0.)
+            nel++;
+        }
 
       result = SparseMatrix (1, nc, nel);
 
       octave_idx_type ii = 0;
       result.xcidx (0) = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  double tmp = elem (idx_arg(j), j);
-	  if (tmp != 0.)
-	    {
-	      result.xdata (ii) = tmp;
-	      result.xridx (ii++) = 0;
-	    }
-	  result.xcidx (j+1) = ii;
-
-	}
+        {
+          double tmp = elem (idx_arg(j), j);
+          if (tmp != 0.)
+            {
+              result.xdata (ii) = tmp;
+              result.xridx (ii++) = 0;
+            }
+          result.xcidx (j+1) = ii;
+
+        }
     }
   else
     {
       idx_arg.resize_fill (nr, 1, 0);
 
       for (octave_idx_type i = cidx(0); i < cidx(1); i++)
-	idx_arg.elem(ridx(i)) = -1;
+        idx_arg.elem(ridx(i)) = -1;
 
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = 0; i < nr; i++)
-	  {
-	    if (idx_arg.elem(i) != -1)
-	      continue;
-	    bool found = false;
-	    for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
-	      if (ridx(k) == i)
-		{
-		  found = true;
-		  break;
-		}
-	    
-	    if (!found)
-	      idx_arg.elem(i) = j;
-
-	  }
+        for (octave_idx_type i = 0; i < nr; i++)
+          {
+            if (idx_arg.elem(i) != -1)
+              continue;
+            bool found = false;
+            for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
+              if (ridx(k) == i)
+                {
+                  found = true;
+                  break;
+                }
+            
+            if (!found)
+              idx_arg.elem(i) = j;
+
+          }
 
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	    {
-	      octave_idx_type ir = ridx (i);
-	      octave_idx_type ix = idx_arg.elem (ir);
-	      double tmp = data (i);
-
-	      if (xisnan (tmp))
-		continue;
-	      else if (ix == -1 || tmp < elem (ir, ix))
-		idx_arg.elem (ir) = j;
-	    }
-	}
+        {
+          for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+            {
+              octave_idx_type ir = ridx (i);
+              octave_idx_type ix = idx_arg.elem (ir);
+              double tmp = data (i);
+
+              if (xisnan (tmp))
+                continue;
+              else if (ix == -1 || tmp < elem (ir, ix))
+                idx_arg.elem (ir) = j;
+            }
+        }
 
       octave_idx_type nel = 0;
       for (octave_idx_type j = 0; j < nr; j++)
-	if (idx_arg.elem(j) == -1 || elem (j, idx_arg.elem (j)) != 0.)
-	  nel++;
+        if (idx_arg.elem(j) == -1 || elem (j, idx_arg.elem (j)) != 0.)
+          nel++;
 
       result = SparseMatrix (nr, 1, nel);
 
@@ -547,23 +547,23 @@
       result.xcidx (0) = 0;
       result.xcidx (1) = nel;
       for (octave_idx_type j = 0; j < nr; j++)
-	{
-	  if (idx_arg(j) == -1)
-	    {
-	      idx_arg(j) = 0;
-	      result.xdata (ii) = octave_NaN;
-	      result.xridx (ii++) = j;
-	    }
-	  else
-	    {
-	      double tmp = elem (j, idx_arg(j));
-	      if (tmp != 0.)
-		{
-		  result.xdata (ii) = tmp;
-		  result.xridx (ii++) = j;
-		}
-	    }
-	}
+        {
+          if (idx_arg(j) == -1)
+            {
+              idx_arg(j) = 0;
+              result.xdata (ii) = octave_NaN;
+              result.xridx (ii++) = j;
+            }
+          else
+            {
+              double tmp = elem (j, idx_arg(j));
+              if (tmp != 0.)
+                {
+                  result.xdata (ii) = tmp;
+                  result.xridx (ii++) = j;
+                }
+            }
+        }
     }
 
   return result;
@@ -673,8 +673,8 @@
       Matrix tmp (nr, nc, atan2 (x, 0.));
 
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
-	  tmp.elem (y.ridx(i), j) = atan2 (x, y.data(i));
+        for (octave_idx_type i = y.cidx (j); i < y.cidx (j+1); i++)
+          tmp.elem (y.ridx(i), j) = atan2 (x, y.data(i));
 
       return SparseMatrix (tmp);
     }
@@ -694,14 +694,14 @@
   for (octave_idx_type i = 0; i < nc; i++)
     {
       for (octave_idx_type j = x.cidx(i); j < x.cidx(i+1); j++)
-	{
-	  double tmp = atan2 (x.data(j), y);
-	  if (tmp != 0.)
-	    {
-	      retval.xdata (ii) = tmp;
-	      retval.xridx (ii++) = x.ridx (j);
-	    }
-	}
+        {
+          double tmp = atan2 (x.data(j), y);
+          if (tmp != 0.)
+            {
+              retval.xdata (ii) = tmp;
+              retval.xridx (ii++) = x.ridx (j);
+            }
+        }
       retval.xcidx (i+1) = ii;
     }
 
@@ -709,12 +709,12 @@
     {
       SparseMatrix retval2 (nr, nc, ii);
       for (octave_idx_type i = 0; i < nc+1; i++)
-	retval2.xcidx (i) = retval.cidx (i);
+        retval2.xcidx (i) = retval.cidx (i);
       for (octave_idx_type i = 0; i < ii; i++)
-	{
-	  retval2.xdata (i) = retval.data (i);
-	  retval2.xridx (i) = retval.ridx (i);
-	}
+        {
+          retval2.xdata (i) = retval.data (i);
+          retval2.xridx (i) = retval.ridx (i);
+        }
       return retval2;
     }
   else
@@ -735,61 +735,61 @@
       octave_idx_type y_nc = y.cols ();
 
       if (x_nr != y_nr || x_nc != y_nc)
-	gripe_nonconformant ("atan2", x_nr, x_nc, y_nr, y_nc);
+        gripe_nonconformant ("atan2", x_nr, x_nc, y_nr, y_nc);
       else
-	{
-	  r = SparseMatrix (x_nr, x_nc, (x.nnz () + y.nnz ()));
+        {
+          r = SparseMatrix (x_nr, x_nc, (x.nnz () + y.nnz ()));
        
-	  octave_idx_type jx = 0;
-	  r.cidx (0) = 0;
-	  for (octave_idx_type i = 0 ; i < x_nc ; i++)
-	    {
-	      octave_idx_type  ja = x.cidx(i);
-	      octave_idx_type  ja_max = x.cidx(i+1);
-	      bool ja_lt_max= ja < ja_max;
+          octave_idx_type jx = 0;
+          r.cidx (0) = 0;
+          for (octave_idx_type i = 0 ; i < x_nc ; i++)
+            {
+              octave_idx_type  ja = x.cidx(i);
+              octave_idx_type  ja_max = x.cidx(i+1);
+              bool ja_lt_max= ja < ja_max;
            
-	      octave_idx_type  jb = y.cidx(i);
-	      octave_idx_type  jb_max = y.cidx(i+1);
-	      bool jb_lt_max = jb < jb_max;
+              octave_idx_type  jb = y.cidx(i);
+              octave_idx_type  jb_max = y.cidx(i+1);
+              bool jb_lt_max = jb < jb_max;
            
-	      while (ja_lt_max || jb_lt_max )
-		{
-		  octave_quit ();
-		  if ((! jb_lt_max) ||
+              while (ja_lt_max || jb_lt_max )
+                {
+                  octave_quit ();
+                  if ((! jb_lt_max) ||
                       (ja_lt_max && (x.ridx(ja) < y.ridx(jb))))
-		    {
-		      r.ridx(jx) = x.ridx(ja);
-		      r.data(jx) = atan2 (x.data(ja), 0.);
-		      jx++;
-		      ja++;
-		      ja_lt_max= ja < ja_max;
-		    }
-		  else if (( !ja_lt_max ) ||
-			   (jb_lt_max && (y.ridx(jb) < x.ridx(ja)) ) )
-		    {
-		      jb++;
-		      jb_lt_max= jb < jb_max;
-		    }
-		  else
-		    {
-		      double tmp = atan2 (x.data(ja), y.data(jb));
-		      if (tmp != 0.)
-			{
+                    {
+                      r.ridx(jx) = x.ridx(ja);
+                      r.data(jx) = atan2 (x.data(ja), 0.);
+                      jx++;
+                      ja++;
+                      ja_lt_max= ja < ja_max;
+                    }
+                  else if (( !ja_lt_max ) ||
+                           (jb_lt_max && (y.ridx(jb) < x.ridx(ja)) ) )
+                    {
+                      jb++;
+                      jb_lt_max= jb < jb_max;
+                    }
+                  else
+                    {
+                      double tmp = atan2 (x.data(ja), y.data(jb));
+                      if (tmp != 0.)
+                        {
                           r.data(jx) = tmp;
                           r.ridx(jx) = x.ridx(ja);
                           jx++;
-			}
-		      ja++;
-		      ja_lt_max= ja < ja_max;
-		      jb++;
-		      jb_lt_max= jb < jb_max;
-		    }
-		}
-	      r.cidx(i+1) = jx;
-	    }
-	  
-	  r.maybe_compress ();
-	}
+                        }
+                      ja++;
+                      ja_lt_max= ja < ja_max;
+                      jb++;
+                      jb_lt_max= jb < jb_max;
+                    }
+                }
+              r.cidx(i+1) = jx;
+            }
+          
+          r.maybe_compress ();
+        }
     }
   else
     (*current_liboctave_error_handler) ("matrix size mismatch");
@@ -823,8 +823,8 @@
 
 SparseMatrix 
 SparseMatrix::dinverse (MatrixType &mattyp, octave_idx_type& info, 
-			double& rcond, const bool, 
-			const bool calccond) const
+                        double& rcond, const bool, 
+                        const bool calccond) const
 {
   SparseMatrix retval;
 
@@ -841,35 +841,35 @@
       mattyp.info ();
 
       if (typ == MatrixType::Diagonal ||
-	  typ == MatrixType::Permuted_Diagonal)
-	{
-	  if (typ == MatrixType::Permuted_Diagonal)
-	    retval = transpose();
-	  else
-	    retval = *this;
-	      
-	  // Force make_unique to be called
-	  double *v = retval.data();
-
-	  if (calccond)
-	    {
-	      double dmax = 0., dmin = octave_Inf; 
-	      for (octave_idx_type i = 0; i < nr; i++)
-		{
-		  double tmp = fabs(v[i]);
-		  if (tmp > dmax)
-		    dmax = tmp;
-		  if (tmp < dmin)
-		    dmin = tmp;
-		}
-	      rcond = dmin / dmax;
-	    }
-
-	  for (octave_idx_type i = 0; i < nr; i++)
-	    v[i] = 1.0 / v[i];
-	}
+          typ == MatrixType::Permuted_Diagonal)
+        {
+          if (typ == MatrixType::Permuted_Diagonal)
+            retval = transpose();
+          else
+            retval = *this;
+              
+          // Force make_unique to be called
+          double *v = retval.data();
+
+          if (calccond)
+            {
+              double dmax = 0., dmin = octave_Inf; 
+              for (octave_idx_type i = 0; i < nr; i++)
+                {
+                  double tmp = fabs(v[i]);
+                  if (tmp > dmax)
+                    dmax = tmp;
+                  if (tmp < dmin)
+                    dmin = tmp;
+                }
+              rcond = dmin / dmax;
+            }
+
+          for (octave_idx_type i = 0; i < nr; i++)
+            v[i] = 1.0 / v[i];
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -877,8 +877,8 @@
 
 SparseMatrix 
 SparseMatrix::tinverse (MatrixType &mattyp, octave_idx_type& info, 
-			double& rcond, const bool, 
-			const bool calccond) const
+                        double& rcond, const bool, 
+                        const bool calccond) const
 {
   SparseMatrix retval;
 
@@ -895,255 +895,255 @@
       mattyp.info ();
 
       if (typ == MatrixType::Upper || typ == MatrixType::Permuted_Upper || 
-	  typ == MatrixType::Lower || typ == MatrixType::Permuted_Lower)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-
-	  if (calccond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nr; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  if (typ == MatrixType::Upper || typ == MatrixType::Lower)
-	    {
-	      octave_idx_type nz = nnz ();
-	      octave_idx_type cx = 0;
-	      octave_idx_type nz2 = nz;
-	      retval = SparseMatrix (nr, nc, nz2);
-
-	      for (octave_idx_type i = 0; i < nr; i++)
-		{
-		  octave_quit ();
-		  // place the 1 in the identity position
-		  octave_idx_type cx_colstart = cx;
-	  
-		  if (cx == nz2)
-		    {
-		      nz2 *= 2;
-		      retval.change_capacity (nz2);
-		    }
-
-		  retval.xcidx(i) = cx;
-		  retval.xridx(cx) = i;
-		  retval.xdata(cx) = 1.0;
-		  cx++;
-
-		  // iterate accross columns of input matrix
-		  for (octave_idx_type j = i+1; j < nr; j++) 
-		    {
-		      double v = 0.;
-		      // iterate to calculate sum
-		      octave_idx_type colXp = retval.xcidx(i);
-		      octave_idx_type colUp = cidx(j);
-		      octave_idx_type rpX, rpU;
-
-		      if (cidx(j) == cidx(j+1))
-			{
-			  (*current_liboctave_error_handler) 
-			    ("division by zero");
-			  goto inverse_singular;
-			}
-
-		      do
-			{
-			  octave_quit ();
-			  rpX = retval.xridx(colXp);
-			  rpU = ridx(colUp);
-
-			  if (rpX < rpU) 
-			    colXp++;
-			  else if (rpX > rpU) 
-			    colUp++;
-			  else 
-			    {
-			      v -= retval.xdata(colXp) * data(colUp);
-			      colXp++;
-			      colUp++;
-			    }
-			} while ((rpX<j) && (rpU<j) && 
-				 (colXp<cx) && (colUp<nz));
-
-		      // get A(m,m)
-		      if (typ == MatrixType::Upper)
-			colUp = cidx(j+1) - 1;
-		      else
-			colUp = cidx(j);
-		      double pivot = data(colUp);
-		      if (pivot == 0. || ridx(colUp) != j) 
-			{
-			  (*current_liboctave_error_handler) 
-			    ("division by zero");
-			  goto inverse_singular;
-			}
-
-		      if (v != 0.)
-			{
-			  if (cx == nz2)
-			    {
-			      nz2 *= 2;
-			      retval.change_capacity (nz2);
-			    }
-
-			  retval.xridx(cx) = j;
-			  retval.xdata(cx) = v / pivot;
-			  cx++;
-			}
-		    }
-
-		  // get A(m,m)
-		  octave_idx_type colUp;
-		  if (typ == MatrixType::Upper)
-		    colUp = cidx(i+1) - 1;
-		  else
-		    colUp = cidx(i);
-		  double pivot = data(colUp);
-		  if (pivot == 0. || ridx(colUp) != i) 
-		    {
-		      (*current_liboctave_error_handler) ("division by zero");
-		      goto inverse_singular;
-		    }
-
-		  if (pivot != 1.0)
-		    for (octave_idx_type j = cx_colstart; j < cx; j++)
-		      retval.xdata(j) /= pivot;
-		}
-	      retval.xcidx(nr) = cx;
-	      retval.maybe_compress ();
-	    }
-	  else
-	    {
-	      octave_idx_type nz = nnz ();
-	      octave_idx_type cx = 0;
-	      octave_idx_type nz2 = nz;
-	      retval = SparseMatrix (nr, nc, nz2);
-
-	      OCTAVE_LOCAL_BUFFER (double, work, nr);
-	      OCTAVE_LOCAL_BUFFER (octave_idx_type, rperm, nr);
-
-	      octave_idx_type *perm = mattyp.triangular_perm();
-	      if (typ == MatrixType::Permuted_Upper)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    rperm[perm[i]] = i;
-		}
-	      else
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    rperm[i] = perm[i];
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    perm[rperm[i]] = i;
-		}
-
-	      for (octave_idx_type i = 0; i < nr; i++)
-		{
-		  octave_quit ();
-		  octave_idx_type iidx = rperm[i];
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    work[j] = 0.;
-
-		  // place the 1 in the identity position
-		  work[iidx] = 1.0;
-
-		  // iterate accross columns of input matrix
-		  for (octave_idx_type j = iidx+1; j < nr; j++) 
-		    {
-		      double v = 0.;
-		      octave_idx_type jidx = perm[j];
-		      // iterate to calculate sum
-		      for (octave_idx_type k = cidx(jidx); 
-			   k < cidx(jidx+1); k++)
-			{
-			  octave_quit ();
-			  v -= work[ridx(k)] * data(k);
-			}
-
-		      // get A(m,m)
-		      double pivot;
-		      if (typ == MatrixType::Permuted_Upper)
-			pivot = data(cidx(jidx+1) - 1);
-		      else
-			pivot = data(cidx(jidx));
-		      if (pivot == 0.) 
-			{
-			  (*current_liboctave_error_handler) 
-			    ("division by zero");
-			  goto inverse_singular;
-			}
-
-		      work[j] = v / pivot;
-		    }
-
-		  // get A(m,m)
-		  octave_idx_type colUp;
-		  if (typ == MatrixType::Permuted_Upper)
-		    colUp = cidx(perm[iidx]+1) - 1;
-		  else
-		    colUp = cidx(perm[iidx]);
-
-		  double pivot = data(colUp);
-		  if (pivot == 0.)
-		    {
-		      (*current_liboctave_error_handler) 
-			("division by zero");
-		      goto inverse_singular;
-		    }
-
-		  octave_idx_type new_cx = cx;
-		  for (octave_idx_type j = iidx; j < nr; j++)
-		    if (work[j] != 0.0)
-		      {
-			new_cx++;
-			if (pivot != 1.0)
-			  work[j] /= pivot;
-		      }
-
-		  if (cx < new_cx)
-		    {
-		      nz2 = (2*nz2 < new_cx ? new_cx : 2*nz2);
-		      retval.change_capacity (nz2);
-		    }
-
-		  retval.xcidx(i) = cx;
-		  for (octave_idx_type j = iidx; j < nr; j++)
-		    if (work[j] != 0.)
-		      {
-			retval.xridx(cx) = j;
-			retval.xdata(cx++) = work[j];
-		      }
-		}
-
-	      retval.xcidx(nr) = cx;
-	      retval.maybe_compress ();
-	    }
-
-	  if (calccond)
-	    {
-	      // Calculate the 1-norm of inverse matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nr; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = retval.cidx(j); 
-		       i < retval.cidx(j+1); i++)
-		    atmp += fabs(retval.data(i));
-		  if (atmp > ainvnorm)
-		    ainvnorm = atmp;
-		}
-
-	      rcond = 1. / ainvnorm / anorm;     
-	    }
-	}
+          typ == MatrixType::Lower || typ == MatrixType::Permuted_Lower)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+
+          if (calccond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nr; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          if (typ == MatrixType::Upper || typ == MatrixType::Lower)
+            {
+              octave_idx_type nz = nnz ();
+              octave_idx_type cx = 0;
+              octave_idx_type nz2 = nz;
+              retval = SparseMatrix (nr, nc, nz2);
+
+              for (octave_idx_type i = 0; i < nr; i++)
+                {
+                  octave_quit ();
+                  // place the 1 in the identity position
+                  octave_idx_type cx_colstart = cx;
+          
+                  if (cx == nz2)
+                    {
+                      nz2 *= 2;
+                      retval.change_capacity (nz2);
+                    }
+
+                  retval.xcidx(i) = cx;
+                  retval.xridx(cx) = i;
+                  retval.xdata(cx) = 1.0;
+                  cx++;
+
+                  // iterate accross columns of input matrix
+                  for (octave_idx_type j = i+1; j < nr; j++) 
+                    {
+                      double v = 0.;
+                      // iterate to calculate sum
+                      octave_idx_type colXp = retval.xcidx(i);
+                      octave_idx_type colUp = cidx(j);
+                      octave_idx_type rpX, rpU;
+
+                      if (cidx(j) == cidx(j+1))
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("division by zero");
+                          goto inverse_singular;
+                        }
+
+                      do
+                        {
+                          octave_quit ();
+                          rpX = retval.xridx(colXp);
+                          rpU = ridx(colUp);
+
+                          if (rpX < rpU) 
+                            colXp++;
+                          else if (rpX > rpU) 
+                            colUp++;
+                          else 
+                            {
+                              v -= retval.xdata(colXp) * data(colUp);
+                              colXp++;
+                              colUp++;
+                            }
+                        } while ((rpX<j) && (rpU<j) && 
+                                 (colXp<cx) && (colUp<nz));
+
+                      // get A(m,m)
+                      if (typ == MatrixType::Upper)
+                        colUp = cidx(j+1) - 1;
+                      else
+                        colUp = cidx(j);
+                      double pivot = data(colUp);
+                      if (pivot == 0. || ridx(colUp) != j) 
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("division by zero");
+                          goto inverse_singular;
+                        }
+
+                      if (v != 0.)
+                        {
+                          if (cx == nz2)
+                            {
+                              nz2 *= 2;
+                              retval.change_capacity (nz2);
+                            }
+
+                          retval.xridx(cx) = j;
+                          retval.xdata(cx) = v / pivot;
+                          cx++;
+                        }
+                    }
+
+                  // get A(m,m)
+                  octave_idx_type colUp;
+                  if (typ == MatrixType::Upper)
+                    colUp = cidx(i+1) - 1;
+                  else
+                    colUp = cidx(i);
+                  double pivot = data(colUp);
+                  if (pivot == 0. || ridx(colUp) != i) 
+                    {
+                      (*current_liboctave_error_handler) ("division by zero");
+                      goto inverse_singular;
+                    }
+
+                  if (pivot != 1.0)
+                    for (octave_idx_type j = cx_colstart; j < cx; j++)
+                      retval.xdata(j) /= pivot;
+                }
+              retval.xcidx(nr) = cx;
+              retval.maybe_compress ();
+            }
+          else
+            {
+              octave_idx_type nz = nnz ();
+              octave_idx_type cx = 0;
+              octave_idx_type nz2 = nz;
+              retval = SparseMatrix (nr, nc, nz2);
+
+              OCTAVE_LOCAL_BUFFER (double, work, nr);
+              OCTAVE_LOCAL_BUFFER (octave_idx_type, rperm, nr);
+
+              octave_idx_type *perm = mattyp.triangular_perm();
+              if (typ == MatrixType::Permuted_Upper)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    rperm[perm[i]] = i;
+                }
+              else
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    rperm[i] = perm[i];
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    perm[rperm[i]] = i;
+                }
+
+              for (octave_idx_type i = 0; i < nr; i++)
+                {
+                  octave_quit ();
+                  octave_idx_type iidx = rperm[i];
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    work[j] = 0.;
+
+                  // place the 1 in the identity position
+                  work[iidx] = 1.0;
+
+                  // iterate accross columns of input matrix
+                  for (octave_idx_type j = iidx+1; j < nr; j++) 
+                    {
+                      double v = 0.;
+                      octave_idx_type jidx = perm[j];
+                      // iterate to calculate sum
+                      for (octave_idx_type k = cidx(jidx); 
+                           k < cidx(jidx+1); k++)
+                        {
+                          octave_quit ();
+                          v -= work[ridx(k)] * data(k);
+                        }
+
+                      // get A(m,m)
+                      double pivot;
+                      if (typ == MatrixType::Permuted_Upper)
+                        pivot = data(cidx(jidx+1) - 1);
+                      else
+                        pivot = data(cidx(jidx));
+                      if (pivot == 0.) 
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("division by zero");
+                          goto inverse_singular;
+                        }
+
+                      work[j] = v / pivot;
+                    }
+
+                  // get A(m,m)
+                  octave_idx_type colUp;
+                  if (typ == MatrixType::Permuted_Upper)
+                    colUp = cidx(perm[iidx]+1) - 1;
+                  else
+                    colUp = cidx(perm[iidx]);
+
+                  double pivot = data(colUp);
+                  if (pivot == 0.)
+                    {
+                      (*current_liboctave_error_handler) 
+                        ("division by zero");
+                      goto inverse_singular;
+                    }
+
+                  octave_idx_type new_cx = cx;
+                  for (octave_idx_type j = iidx; j < nr; j++)
+                    if (work[j] != 0.0)
+                      {
+                        new_cx++;
+                        if (pivot != 1.0)
+                          work[j] /= pivot;
+                      }
+
+                  if (cx < new_cx)
+                    {
+                      nz2 = (2*nz2 < new_cx ? new_cx : 2*nz2);
+                      retval.change_capacity (nz2);
+                    }
+
+                  retval.xcidx(i) = cx;
+                  for (octave_idx_type j = iidx; j < nr; j++)
+                    if (work[j] != 0.)
+                      {
+                        retval.xridx(cx) = j;
+                        retval.xdata(cx++) = work[j];
+                      }
+                }
+
+              retval.xcidx(nr) = cx;
+              retval.maybe_compress ();
+            }
+
+          if (calccond)
+            {
+              // Calculate the 1-norm of inverse matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nr; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = retval.cidx(j); 
+                       i < retval.cidx(j+1); i++)
+                    atmp += fabs(retval.data(i));
+                  if (atmp > ainvnorm)
+                    ainvnorm = atmp;
+                }
+
+              rcond = 1. / ainvnorm / anorm;     
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -1154,7 +1154,7 @@
 
 SparseMatrix
 SparseMatrix::inverse (MatrixType &mattype, octave_idx_type& info, 
-		       double& rcond, int, int calc_cond) const
+                       double& rcond, int, int calc_cond) const
 {
   int typ = mattype.type (false);
   SparseMatrix ret;
@@ -1174,43 +1174,43 @@
   else
     {
       if (mattype.is_hermitian())
-	{
-	  MatrixType tmp_typ (MatrixType::Upper);
-	  SparseCHOL fact (*this, info, false);
-	  rcond = fact.rcond();
-	  if (info == 0)
-	    {
-	      double rcond2;
-	      SparseMatrix Q = fact.Q();
-	      SparseMatrix InvL = fact.L().transpose().tinverse(tmp_typ,
-					   info, rcond2, true, false);
-	      ret = Q * InvL.transpose() * InvL * Q.transpose();
-	    }
-	  else
-	    {
-	      // Matrix is either singular or not positive definite
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Full;
-	    }
-	}
+        {
+          MatrixType tmp_typ (MatrixType::Upper);
+          SparseCHOL fact (*this, info, false);
+          rcond = fact.rcond();
+          if (info == 0)
+            {
+              double rcond2;
+              SparseMatrix Q = fact.Q();
+              SparseMatrix InvL = fact.L().transpose().tinverse(tmp_typ,
+                                           info, rcond2, true, false);
+              ret = Q * InvL.transpose() * InvL * Q.transpose();
+            }
+          else
+            {
+              // Matrix is either singular or not positive definite
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Full;
+            }
+        }
 
       if (!mattype.is_hermitian())
-	{
-	  octave_idx_type n = rows();
-	  ColumnVector Qinit(n);
-	  for (octave_idx_type i = 0; i < n; i++)
-	    Qinit(i) = i;
-
-	  MatrixType tmp_typ (MatrixType::Upper);
-	  SparseLU fact (*this, Qinit, Matrix(), false, false);
-	  rcond = fact.rcond();
-	  double rcond2;
-	  SparseMatrix InvL = fact.L().transpose().tinverse(tmp_typ, 
-					   info, rcond2, true, false);
-	  SparseMatrix InvU = fact.U().tinverse(tmp_typ, info, rcond2,
-					   true, false).transpose();
-	  ret = fact.Pc().transpose() * InvU * InvL * fact.Pr();
-	}
+        {
+          octave_idx_type n = rows();
+          ColumnVector Qinit(n);
+          for (octave_idx_type i = 0; i < n; i++)
+            Qinit(i) = i;
+
+          MatrixType tmp_typ (MatrixType::Upper);
+          SparseLU fact (*this, Qinit, Matrix(), false, false);
+          rcond = fact.rcond();
+          double rcond2;
+          SparseMatrix InvL = fact.L().transpose().tinverse(tmp_typ, 
+                                           info, rcond2, true, false);
+          SparseMatrix InvU = fact.U().tinverse(tmp_typ, info, rcond2,
+                                           true, false).transpose();
+          ret = fact.Pc().transpose() * InvU * InvL * fact.Pr();
+        }
     }
 
   return ret;
@@ -1255,19 +1255,19 @@
 
       double tmp = octave_sparse_params::get_key ("spumoni");
       if (!xisnan (tmp))
-	Control (UMFPACK_PRL) = tmp;
+        Control (UMFPACK_PRL) = tmp;
 
       tmp = octave_sparse_params::get_key ("piv_tol");
       if (!xisnan (tmp))
-	{
-	  Control (UMFPACK_SYM_PIVOT_TOLERANCE) = tmp;
-	  Control (UMFPACK_PIVOT_TOLERANCE) = tmp;
-	}
+        {
+          Control (UMFPACK_SYM_PIVOT_TOLERANCE) = tmp;
+          Control (UMFPACK_PIVOT_TOLERANCE) = tmp;
+        }
 
       // Set whether we are allowed to modify Q or not
       tmp = octave_sparse_params::get_key ("autoamd");
       if (!xisnan (tmp))
-	Control (UMFPACK_FIXQ) = tmp;
+        Control (UMFPACK_FIXQ) = tmp;
 
       // Turn-off UMFPACK scaling for LU 
       Control (UMFPACK_SCALE) = UMFPACK_SCALE_NONE;
@@ -1284,61 +1284,61 @@
       Matrix Info (1, UMFPACK_INFO);
       double *info = Info.fortran_vec ();
       int status = UMFPACK_DNAME (qsymbolic) (nr, nc, Ap, Ai, 
-					 Ax, 0, &Symbolic, control, info);
+                                         Ax, 0, &Symbolic, control, info);
 
       if (status < 0)
-	{
-	  (*current_liboctave_error_handler) 
-	    ("SparseMatrix::determinant symbolic factorization failed");
-
-	  UMFPACK_DNAME (report_status) (control, status);
-	  UMFPACK_DNAME (report_info) (control, info);
-
-	  UMFPACK_DNAME (free_symbolic) (&Symbolic) ;
-	}
+        {
+          (*current_liboctave_error_handler) 
+            ("SparseMatrix::determinant symbolic factorization failed");
+
+          UMFPACK_DNAME (report_status) (control, status);
+          UMFPACK_DNAME (report_info) (control, info);
+
+          UMFPACK_DNAME (free_symbolic) (&Symbolic) ;
+        }
       else
-	{
-	  UMFPACK_DNAME (report_symbolic) (Symbolic, control);
-
-	  void *Numeric;
-	  status = UMFPACK_DNAME (numeric) (Ap, Ai, Ax, Symbolic, 
-				       &Numeric, control, info) ;
-	  UMFPACK_DNAME (free_symbolic) (&Symbolic) ;
-
-	  rcond = Info (UMFPACK_RCOND);
-
-	  if (status < 0)
-	    {
-	      (*current_liboctave_error_handler) 
-		("SparseMatrix::determinant numeric factorization failed");
-
-	      UMFPACK_DNAME (report_status) (control, status);
-	      UMFPACK_DNAME (report_info) (control, info);
-
-	      UMFPACK_DNAME (free_numeric) (&Numeric);
-	    }
-	  else
-	    {
-	      UMFPACK_DNAME (report_numeric) (Numeric, control);
-
-	      double c10, e10;
-
-	      status = UMFPACK_DNAME (get_determinant) (&c10, &e10, Numeric, info);
-
-	      if (status < 0)
-		{
-		  (*current_liboctave_error_handler) 
-		    ("SparseMatrix::determinant error calculating determinant");
-		  
-		  UMFPACK_DNAME (report_status) (control, status);
-		  UMFPACK_DNAME (report_info) (control, info);
-		}
-	      else
-		retval = DET (c10, e10, 10);
-
-	      UMFPACK_DNAME (free_numeric) (&Numeric);
-	    }
-	}
+        {
+          UMFPACK_DNAME (report_symbolic) (Symbolic, control);
+
+          void *Numeric;
+          status = UMFPACK_DNAME (numeric) (Ap, Ai, Ax, Symbolic, 
+                                       &Numeric, control, info) ;
+          UMFPACK_DNAME (free_symbolic) (&Symbolic) ;
+
+          rcond = Info (UMFPACK_RCOND);
+
+          if (status < 0)
+            {
+              (*current_liboctave_error_handler) 
+                ("SparseMatrix::determinant numeric factorization failed");
+
+              UMFPACK_DNAME (report_status) (control, status);
+              UMFPACK_DNAME (report_info) (control, info);
+
+              UMFPACK_DNAME (free_numeric) (&Numeric);
+            }
+          else
+            {
+              UMFPACK_DNAME (report_numeric) (Numeric, control);
+
+              double c10, e10;
+
+              status = UMFPACK_DNAME (get_determinant) (&c10, &e10, Numeric, info);
+
+              if (status < 0)
+                {
+                  (*current_liboctave_error_handler) 
+                    ("SparseMatrix::determinant error calculating determinant");
+                  
+                  UMFPACK_DNAME (report_status) (control, status);
+                  UMFPACK_DNAME (report_info) (control, info);
+                }
+              else
+                retval = DET (c10, e10, 10);
+
+              UMFPACK_DNAME (free_numeric) (&Numeric);
+            }
+        }
     }
 #else
   (*current_liboctave_error_handler) ("UMFPACK not installed");
@@ -1349,8 +1349,8 @@
 
 Matrix
 SparseMatrix::dsolve (MatrixType &mattype, const Matrix& b, octave_idx_type& err,
-		      double& rcond, solve_singularity_handler, 
-		      bool calc_cond) const
+                      double& rcond, solve_singularity_handler, 
+                      bool calc_cond) const
 {
   Matrix retval;
 
@@ -1371,37 +1371,37 @@
       mattype.info ();
 
       if (typ == MatrixType::Diagonal ||
-	  typ == MatrixType::Permuted_Diagonal)
-	{
-	  retval.resize (nc, b.cols(), 0.);
-	  if (typ == MatrixType::Diagonal)
-	    for (octave_idx_type j = 0; j < b.cols(); j++)
-	      for (octave_idx_type i = 0; i < nm; i++)
-		retval(i,j) = b(i,j) / data (i);
-	  else
-	    for (octave_idx_type j = 0; j < b.cols(); j++)
-	      for (octave_idx_type k = 0; k < nc; k++)
-		for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-		  retval(k,j) = b(ridx(i),j) / data (i);
-
-	  if (calc_cond)
-	    {
-	      double dmax = 0., dmin = octave_Inf; 
-	      for (octave_idx_type i = 0; i < nm; i++)
-		{
-		  double tmp = fabs(data(i));
-		  if (tmp > dmax)
-		    dmax = tmp;
-		  if (tmp < dmin)
-		    dmin = tmp;
-		}
-	      rcond = dmin / dmax;
-	    }
-	  else
-	    rcond = 1.;
-	}
+          typ == MatrixType::Permuted_Diagonal)
+        {
+          retval.resize (nc, b.cols(), 0.);
+          if (typ == MatrixType::Diagonal)
+            for (octave_idx_type j = 0; j < b.cols(); j++)
+              for (octave_idx_type i = 0; i < nm; i++)
+                retval(i,j) = b(i,j) / data (i);
+          else
+            for (octave_idx_type j = 0; j < b.cols(); j++)
+              for (octave_idx_type k = 0; k < nc; k++)
+                for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                  retval(k,j) = b(ridx(i),j) / data (i);
+
+          if (calc_cond)
+            {
+              double dmax = 0., dmin = octave_Inf; 
+              for (octave_idx_type i = 0; i < nm; i++)
+                {
+                  double tmp = fabs(data(i));
+                  if (tmp > dmax)
+                    dmax = tmp;
+                  if (tmp < dmin)
+                    dmin = tmp;
+                }
+              rcond = dmin / dmax;
+            }
+          else
+            rcond = 1.;
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -1409,8 +1409,8 @@
 
 SparseMatrix
 SparseMatrix::dsolve (MatrixType &mattype, const SparseMatrix& b, 
-		      octave_idx_type& err, double& rcond, 
-		      solve_singularity_handler, bool calc_cond) const
+                      octave_idx_type& err, double& rcond, 
+                      solve_singularity_handler, bool calc_cond) const
 {
   SparseMatrix retval;
 
@@ -1431,67 +1431,67 @@
       mattype.info ();
 
       if (typ == MatrixType::Diagonal ||
-	  typ == MatrixType::Permuted_Diagonal)
-	{
-	  octave_idx_type b_nc = b.cols ();
-	  octave_idx_type b_nz = b.nnz ();
-	  retval = SparseMatrix (nc, b_nc, b_nz);
-
-	  retval.xcidx(0) = 0;
-	  octave_idx_type ii = 0;
-	  if (typ == MatrixType::Diagonal)
-	    for (octave_idx_type j = 0; j < b_nc; j++)
-	      {
-		for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		  {
-		    if (b.ridx(i) >= nm)
-		      break;
-		    retval.xridx (ii) = b.ridx(i);
-		    retval.xdata (ii++) = b.data(i) / data (b.ridx (i));
-		  }
-		retval.xcidx(j+1) = ii;
-	      }
-	  else
-	    for (octave_idx_type j = 0; j < b_nc; j++)
-	      {
-		for (octave_idx_type l = 0; l < nc; l++)
-		  for (octave_idx_type i = cidx(l); i < cidx(l+1); i++)
-		    {
-		      bool found = false;
-		      octave_idx_type k;
-		      for (k = b.cidx(j); k < b.cidx(j+1); k++)
-			if (ridx(i) == b.ridx(k))
-			  {
-			    found = true;
-			    break;
-			  }
-		      if (found)
-			{
-			  retval.xridx (ii) = l;
-			  retval.xdata (ii++) = b.data(k) / data (i);
-			}
-		    }
-		retval.xcidx(j+1) = ii;
-	      }
-
-	  if (calc_cond)
-	    {
-	      double dmax = 0., dmin = octave_Inf; 
-	      for (octave_idx_type i = 0; i < nm; i++)
-		{
-		  double tmp = fabs(data(i));
-		  if (tmp > dmax)
-		    dmax = tmp;
-		  if (tmp < dmin)
-		    dmin = tmp;
-		}
-	      rcond = dmin / dmax;
-	    }
-	  else
-	    rcond = 1.;
-	}
+          typ == MatrixType::Permuted_Diagonal)
+        {
+          octave_idx_type b_nc = b.cols ();
+          octave_idx_type b_nz = b.nnz ();
+          retval = SparseMatrix (nc, b_nc, b_nz);
+
+          retval.xcidx(0) = 0;
+          octave_idx_type ii = 0;
+          if (typ == MatrixType::Diagonal)
+            for (octave_idx_type j = 0; j < b_nc; j++)
+              {
+                for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                  {
+                    if (b.ridx(i) >= nm)
+                      break;
+                    retval.xridx (ii) = b.ridx(i);
+                    retval.xdata (ii++) = b.data(i) / data (b.ridx (i));
+                  }
+                retval.xcidx(j+1) = ii;
+              }
+          else
+            for (octave_idx_type j = 0; j < b_nc; j++)
+              {
+                for (octave_idx_type l = 0; l < nc; l++)
+                  for (octave_idx_type i = cidx(l); i < cidx(l+1); i++)
+                    {
+                      bool found = false;
+                      octave_idx_type k;
+                      for (k = b.cidx(j); k < b.cidx(j+1); k++)
+                        if (ridx(i) == b.ridx(k))
+                          {
+                            found = true;
+                            break;
+                          }
+                      if (found)
+                        {
+                          retval.xridx (ii) = l;
+                          retval.xdata (ii++) = b.data(k) / data (i);
+                        }
+                    }
+                retval.xcidx(j+1) = ii;
+              }
+
+          if (calc_cond)
+            {
+              double dmax = 0., dmin = octave_Inf; 
+              for (octave_idx_type i = 0; i < nm; i++)
+                {
+                  double tmp = fabs(data(i));
+                  if (tmp > dmax)
+                    dmax = tmp;
+                  if (tmp < dmin)
+                    dmin = tmp;
+                }
+              rcond = dmin / dmax;
+            }
+          else
+            rcond = 1.;
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -1499,8 +1499,8 @@
 
 ComplexMatrix
 SparseMatrix::dsolve (MatrixType &mattype, const ComplexMatrix& b,
-		      octave_idx_type& err, double& rcond,
-		      solve_singularity_handler, bool calc_cond) const
+                      octave_idx_type& err, double& rcond,
+                      solve_singularity_handler, bool calc_cond) const
 {
   ComplexMatrix retval;
 
@@ -1521,37 +1521,37 @@
       mattype.info ();
 
       if (typ == MatrixType::Diagonal ||
-	  typ == MatrixType::Permuted_Diagonal)
-	{
-	  retval.resize (nc, b.cols(), 0);
-	  if (typ == MatrixType::Diagonal)
-	    for (octave_idx_type j = 0; j < b.cols(); j++)
-		for (octave_idx_type i = 0; i < nm; i++)
-		  retval(i,j) = b(i,j) / data (i);
-	  else
-	    for (octave_idx_type j = 0; j < b.cols(); j++)
-	      for (octave_idx_type k = 0; k < nc; k++)
-		for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-		  retval(k,j) = b(ridx(i),j) / data (i);
-	    
-	  if (calc_cond)
-	    {
-	      double dmax = 0., dmin = octave_Inf; 
-	      for (octave_idx_type i = 0; i < nm; i++)
-		{
-		  double tmp = fabs(data(i));
-		  if (tmp > dmax)
-		    dmax = tmp;
-		  if (tmp < dmin)
-		    dmin = tmp;
-		}
-	      rcond = dmin / dmax;
-	    }
-	  else
-	    rcond = 1.;
-	}
+          typ == MatrixType::Permuted_Diagonal)
+        {
+          retval.resize (nc, b.cols(), 0);
+          if (typ == MatrixType::Diagonal)
+            for (octave_idx_type j = 0; j < b.cols(); j++)
+                for (octave_idx_type i = 0; i < nm; i++)
+                  retval(i,j) = b(i,j) / data (i);
+          else
+            for (octave_idx_type j = 0; j < b.cols(); j++)
+              for (octave_idx_type k = 0; k < nc; k++)
+                for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                  retval(k,j) = b(ridx(i),j) / data (i);
+            
+          if (calc_cond)
+            {
+              double dmax = 0., dmin = octave_Inf; 
+              for (octave_idx_type i = 0; i < nm; i++)
+                {
+                  double tmp = fabs(data(i));
+                  if (tmp > dmax)
+                    dmax = tmp;
+                  if (tmp < dmin)
+                    dmin = tmp;
+                }
+              rcond = dmin / dmax;
+            }
+          else
+            rcond = 1.;
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -1559,8 +1559,8 @@
 
 SparseComplexMatrix
 SparseMatrix::dsolve (MatrixType &mattype, const SparseComplexMatrix& b,
-		     octave_idx_type& err, double& rcond, 
-		     solve_singularity_handler, bool calc_cond) const
+                     octave_idx_type& err, double& rcond, 
+                     solve_singularity_handler, bool calc_cond) const
 {
   SparseComplexMatrix retval;
 
@@ -1581,67 +1581,67 @@
       mattype.info ();
 
       if (typ == MatrixType::Diagonal ||
-	  typ == MatrixType::Permuted_Diagonal)
-	{
-	  octave_idx_type b_nc = b.cols ();
-	  octave_idx_type b_nz = b.nnz ();
-	  retval = SparseComplexMatrix (nc, b_nc, b_nz);
-
-	  retval.xcidx(0) = 0;
-	  octave_idx_type ii = 0;
-	  if (typ == MatrixType::Diagonal)
-	    for (octave_idx_type j = 0; j < b.cols(); j++)
-	      {
-		for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		  {
-		    if (b.ridx(i) >= nm)
-		      break;
-		    retval.xridx (ii) = b.ridx(i);
-		    retval.xdata (ii++) = b.data(i) / data (b.ridx (i));
-		  }
-		retval.xcidx(j+1) = ii;
-	      }
-	  else
-	    for (octave_idx_type j = 0; j < b.cols(); j++)
-	      {
-		for (octave_idx_type l = 0; l < nc; l++)
-		  for (octave_idx_type i = cidx(l); i < cidx(l+1); i++)
-		    {
-		      bool found = false;
-		      octave_idx_type k;
-		      for (k = b.cidx(j); k < b.cidx(j+1); k++)
-			if (ridx(i) == b.ridx(k))
-			  {
-			    found = true;
-			    break;
-			  }
-		      if (found)
-			{
-			  retval.xridx (ii) = l;
-			  retval.xdata (ii++) = b.data(k) / data (i);
-			}
-		    }
-		retval.xcidx(j+1) = ii;
-	      }
-	    
-	  if (calc_cond)
-	    {
-	      double dmax = 0., dmin = octave_Inf; 
-	      for (octave_idx_type i = 0; i < nm; i++)
-		{
-		  double tmp = fabs(data(i));
-		  if (tmp > dmax)
-		    dmax = tmp;
-		  if (tmp < dmin)
-		    dmin = tmp;
-		}
-	      rcond = dmin / dmax;
-	    }
-	  else
-	    rcond = 1.;
-	}
+          typ == MatrixType::Permuted_Diagonal)
+        {
+          octave_idx_type b_nc = b.cols ();
+          octave_idx_type b_nz = b.nnz ();
+          retval = SparseComplexMatrix (nc, b_nc, b_nz);
+
+          retval.xcidx(0) = 0;
+          octave_idx_type ii = 0;
+          if (typ == MatrixType::Diagonal)
+            for (octave_idx_type j = 0; j < b.cols(); j++)
+              {
+                for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                  {
+                    if (b.ridx(i) >= nm)
+                      break;
+                    retval.xridx (ii) = b.ridx(i);
+                    retval.xdata (ii++) = b.data(i) / data (b.ridx (i));
+                  }
+                retval.xcidx(j+1) = ii;
+              }
+          else
+            for (octave_idx_type j = 0; j < b.cols(); j++)
+              {
+                for (octave_idx_type l = 0; l < nc; l++)
+                  for (octave_idx_type i = cidx(l); i < cidx(l+1); i++)
+                    {
+                      bool found = false;
+                      octave_idx_type k;
+                      for (k = b.cidx(j); k < b.cidx(j+1); k++)
+                        if (ridx(i) == b.ridx(k))
+                          {
+                            found = true;
+                            break;
+                          }
+                      if (found)
+                        {
+                          retval.xridx (ii) = l;
+                          retval.xdata (ii++) = b.data(k) / data (i);
+                        }
+                    }
+                retval.xcidx(j+1) = ii;
+              }
+            
+          if (calc_cond)
+            {
+              double dmax = 0., dmin = octave_Inf; 
+              for (octave_idx_type i = 0; i < nm; i++)
+                {
+                  double tmp = fabs(data(i));
+                  if (tmp > dmax)
+                    dmax = tmp;
+                  if (tmp < dmin)
+                    dmin = tmp;
+                }
+              rcond = dmin / dmax;
+            }
+          else
+            rcond = 1.;
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -1649,9 +1649,9 @@
 
 Matrix
 SparseMatrix::utsolve (MatrixType &mattype, const Matrix& b,
-		       octave_idx_type& err, double& rcond,
-		       solve_singularity_handler sing_handler, 
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond,
+                       solve_singularity_handler sing_handler, 
+                       bool calc_cond) const
 {
   Matrix retval;
 
@@ -1672,211 +1672,211 @@
       mattype.info ();
 
       if (typ == MatrixType::Permuted_Upper ||
-	  typ == MatrixType::Upper)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  octave_idx_type b_nc = b.cols ();
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  if (typ == MatrixType::Permuted_Upper)
-	    {
-	      retval.resize (nc, b_nc);
-	      octave_idx_type *perm = mattype.triangular_perm ();
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    work[i] = b(i,j);
-		  for (octave_idx_type i = nr; i < nc; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      octave_idx_type kidx = perm[k];
-
-		      if (work[k] != 0.)
-			{
-			  if (ridx(cidx(kidx+1)-1) != k ||
-			      data(cidx(kidx+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(cidx(kidx+1)-1);
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(kidx); 
-			       i < cidx(kidx+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval.xelem (perm[i], j) = work[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  octave_idx_type iidx = perm[k];
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(iidx+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(iidx); 
-				   i < cidx(iidx+1)-1; i++)
-				{
-				  octave_idx_type idx2 = ridx(i);
-				  work[idx2] = work[idx2] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-	      retval.resize (nc, b_nc);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    work[i] = b(i,j);
-		  for (octave_idx_type i = nr; i < nc; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      if (work[k] != 0.)
-			{
-			  if (ridx(cidx(k+1)-1) != k ||
-			      data(cidx(k+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(cidx(k+1)-1);
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval.xelem (i, j) = work[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Upper)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          octave_idx_type b_nc = b.cols ();
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          if (typ == MatrixType::Permuted_Upper)
+            {
+              retval.resize (nc, b_nc);
+              octave_idx_type *perm = mattype.triangular_perm ();
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    work[i] = b(i,j);
+                  for (octave_idx_type i = nr; i < nc; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      octave_idx_type kidx = perm[k];
+
+                      if (work[k] != 0.)
+                        {
+                          if (ridx(cidx(kidx+1)-1) != k ||
+                              data(cidx(kidx+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(cidx(kidx+1)-1);
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(kidx); 
+                               i < cidx(kidx+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval.xelem (perm[i], j) = work[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          octave_idx_type iidx = perm[k];
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(iidx+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(iidx); 
+                                   i < cidx(iidx+1)-1; i++)
+                                {
+                                  octave_idx_type idx2 = ridx(i);
+                                  work[idx2] = work[idx2] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+              retval.resize (nc, b_nc);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    work[i] = b(i,j);
+                  for (octave_idx_type i = nr; i < nc; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      if (work[k] != 0.)
+                        {
+                          if (ridx(cidx(k+1)-1) != k ||
+                              data(cidx(k+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(cidx(k+1)-1);
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval.xelem (i, j) = work[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -1884,9 +1884,9 @@
 
 SparseMatrix
 SparseMatrix::utsolve (MatrixType &mattype, const SparseMatrix& b,
-		       octave_idx_type& err, double& rcond, 
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond, 
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   SparseMatrix retval;
 
@@ -1907,273 +1907,273 @@
       mattype.info ();
 
       if (typ == MatrixType::Permuted_Upper ||
-	  typ == MatrixType::Upper)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  octave_idx_type b_nc = b.cols ();
-	  octave_idx_type b_nz = b.nnz ();
-	  retval = SparseMatrix (nc, b_nc, b_nz);
-	  retval.xcidx(0) = 0;
-	  octave_idx_type ii = 0;
-	  octave_idx_type x_nz = b_nz;
-
-	  if (typ == MatrixType::Permuted_Upper)
-	    {
-	      octave_idx_type *perm = mattype.triangular_perm ();
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-
-	      OCTAVE_LOCAL_BUFFER (octave_idx_type, rperm, nc);
-	      for (octave_idx_type i = 0; i < nc; i++)
-		rperm[perm[i]] = i;
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    work[b.ridx(i)] = b.data(i);
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      octave_idx_type kidx = perm[k];
-
-		      if (work[k] != 0.)
-			{
-			  if (ridx(cidx(kidx+1)-1) != k ||
-			      data(cidx(kidx+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(cidx(kidx+1)-1);
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(kidx); 
-			       i < cidx(kidx+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[rperm[i]] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = work[rperm[i]];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  octave_idx_type iidx = perm[k];
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(iidx+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(iidx); 
-				   i < cidx(iidx+1)-1; i++)
-				{
-				  octave_idx_type idx2 = ridx(i);
-				  work[idx2] = work[idx2] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    work[b.ridx(i)] = b.data(i);
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      if (work[k] != 0.)
-			{
-			  if (ridx(cidx(k+1)-1) != k ||
-			      data(cidx(k+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(cidx(k+1)-1);
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = work[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1)-1; i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Upper)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          octave_idx_type b_nc = b.cols ();
+          octave_idx_type b_nz = b.nnz ();
+          retval = SparseMatrix (nc, b_nc, b_nz);
+          retval.xcidx(0) = 0;
+          octave_idx_type ii = 0;
+          octave_idx_type x_nz = b_nz;
+
+          if (typ == MatrixType::Permuted_Upper)
+            {
+              octave_idx_type *perm = mattype.triangular_perm ();
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+
+              OCTAVE_LOCAL_BUFFER (octave_idx_type, rperm, nc);
+              for (octave_idx_type i = 0; i < nc; i++)
+                rperm[perm[i]] = i;
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    work[b.ridx(i)] = b.data(i);
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      octave_idx_type kidx = perm[k];
+
+                      if (work[k] != 0.)
+                        {
+                          if (ridx(cidx(kidx+1)-1) != k ||
+                              data(cidx(kidx+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(cidx(kidx+1)-1);
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(kidx); 
+                               i < cidx(kidx+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[rperm[i]] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = work[rperm[i]];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          octave_idx_type iidx = perm[k];
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(iidx+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(iidx); 
+                                   i < cidx(iidx+1)-1; i++)
+                                {
+                                  octave_idx_type idx2 = ridx(i);
+                                  work[idx2] = work[idx2] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    work[b.ridx(i)] = b.data(i);
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      if (work[k] != 0.)
+                        {
+                          if (ridx(cidx(k+1)-1) != k ||
+                              data(cidx(k+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(cidx(k+1)-1);
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = work[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1)-1; i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
   return retval;
 }
 
 ComplexMatrix
 SparseMatrix::utsolve (MatrixType &mattype, const ComplexMatrix& b, 
-		       octave_idx_type& err, double& rcond, 
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond, 
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   ComplexMatrix retval;
 
@@ -2194,214 +2194,214 @@
       mattype.info ();
       
       if (typ == MatrixType::Permuted_Upper ||
-	  typ == MatrixType::Upper)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  octave_idx_type b_nc = b.cols ();
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  if (typ == MatrixType::Permuted_Upper)
-	    {
-	      retval.resize (nc, b_nc);
-	      octave_idx_type *perm = mattype.triangular_perm ();
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    cwork[i] = b(i,j);
-		  for (octave_idx_type i = nr; i < nc; i++)
-		    cwork[i] = 0.;
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      octave_idx_type kidx = perm[k];
-
-		      if (cwork[k] != 0.)
-			{
-			  if (ridx(cidx(kidx+1)-1) != k ||
-			      data(cidx(kidx+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(cidx(kidx+1)-1);
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(kidx); 
-			       i < cidx(kidx+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval.xelem (perm[i], j) = cwork[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  octave_idx_type iidx = perm[k];
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(iidx+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(iidx); 
-				   i < cidx(iidx+1)-1; i++)
-				{
-				  octave_idx_type idx2 = ridx(i);
-				  work[idx2] = work[idx2] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-	      retval.resize (nc, b_nc);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    cwork[i] = b(i,j);
-		  for (octave_idx_type i = nr; i < nc; i++)
-		    cwork[i] = 0.;
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      if (cwork[k] != 0.)
-			{
-			  if (ridx(cidx(k+1)-1) != k ||
-			      data(cidx(k+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(cidx(k+1)-1);
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      cwork[iidx] = cwork[iidx] - tmp  * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval.xelem (i, j) = cwork[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1)-1; i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Upper)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          octave_idx_type b_nc = b.cols ();
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          if (typ == MatrixType::Permuted_Upper)
+            {
+              retval.resize (nc, b_nc);
+              octave_idx_type *perm = mattype.triangular_perm ();
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    cwork[i] = b(i,j);
+                  for (octave_idx_type i = nr; i < nc; i++)
+                    cwork[i] = 0.;
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      octave_idx_type kidx = perm[k];
+
+                      if (cwork[k] != 0.)
+                        {
+                          if (ridx(cidx(kidx+1)-1) != k ||
+                              data(cidx(kidx+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(cidx(kidx+1)-1);
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(kidx); 
+                               i < cidx(kidx+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval.xelem (perm[i], j) = cwork[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          octave_idx_type iidx = perm[k];
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(iidx+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(iidx); 
+                                   i < cidx(iidx+1)-1; i++)
+                                {
+                                  octave_idx_type idx2 = ridx(i);
+                                  work[idx2] = work[idx2] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+              retval.resize (nc, b_nc);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    cwork[i] = b(i,j);
+                  for (octave_idx_type i = nr; i < nc; i++)
+                    cwork[i] = 0.;
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      if (cwork[k] != 0.)
+                        {
+                          if (ridx(cidx(k+1)-1) != k ||
+                              data(cidx(k+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(cidx(k+1)-1);
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              cwork[iidx] = cwork[iidx] - tmp  * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval.xelem (i, j) = cwork[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1)-1; i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -2409,9 +2409,9 @@
 
 SparseComplexMatrix
 SparseMatrix::utsolve (MatrixType &mattype, const SparseComplexMatrix& b,
-		       octave_idx_type& err, double& rcond, 
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond, 
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   SparseComplexMatrix retval;
 
@@ -2432,266 +2432,266 @@
       mattype.info ();
       
       if (typ == MatrixType::Permuted_Upper ||
-	  typ == MatrixType::Upper)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  octave_idx_type b_nc = b.cols ();
-	  octave_idx_type b_nz = b.nnz ();
-	  retval = SparseComplexMatrix (nc, b_nc, b_nz);
-	  retval.xcidx(0) = 0;
-	  octave_idx_type ii = 0;
-	  octave_idx_type x_nz = b_nz;
-
-	  if (typ == MatrixType::Permuted_Upper)
-	    {
-	      octave_idx_type *perm = mattype.triangular_perm ();
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-
-	      OCTAVE_LOCAL_BUFFER (octave_idx_type, rperm, nc);
-	      for (octave_idx_type i = 0; i < nc; i++)
-		rperm[perm[i]] = i;
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    cwork[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    cwork[b.ridx(i)] = b.data(i);
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      octave_idx_type kidx = perm[k];
-
-		      if (cwork[k] != 0.)
-			{
-			  if (ridx(cidx(kidx+1)-1) != k ||
-			      data(cidx(kidx+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(cidx(kidx+1)-1);
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(kidx); 
-			       i < cidx(kidx+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[rperm[i]] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = cwork[rperm[i]];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  octave_idx_type iidx = perm[k];
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(iidx+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(iidx); 
-				   i < cidx(iidx+1)-1; i++)
-				{
-				  octave_idx_type idx2 = ridx(i);
-				  work[idx2] = work[idx2] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    cwork[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    cwork[b.ridx(i)] = b.data(i);
-
-		  for (octave_idx_type k = nc-1; k >= 0; k--)
-		    {
-		      if (cwork[k] != 0.)
-			{
-			  if (ridx(cidx(k+1)-1) != k ||
-			      data(cidx(k+1)-1) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(cidx(k+1)-1);
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = cwork[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k >= 0; k--)
-			{
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k+1)-1);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1)-1; i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = 0; i < j+1; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Upper)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          octave_idx_type b_nc = b.cols ();
+          octave_idx_type b_nz = b.nnz ();
+          retval = SparseComplexMatrix (nc, b_nc, b_nz);
+          retval.xcidx(0) = 0;
+          octave_idx_type ii = 0;
+          octave_idx_type x_nz = b_nz;
+
+          if (typ == MatrixType::Permuted_Upper)
+            {
+              octave_idx_type *perm = mattype.triangular_perm ();
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+
+              OCTAVE_LOCAL_BUFFER (octave_idx_type, rperm, nc);
+              for (octave_idx_type i = 0; i < nc; i++)
+                rperm[perm[i]] = i;
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    cwork[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    cwork[b.ridx(i)] = b.data(i);
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      octave_idx_type kidx = perm[k];
+
+                      if (cwork[k] != 0.)
+                        {
+                          if (ridx(cidx(kidx+1)-1) != k ||
+                              data(cidx(kidx+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(cidx(kidx+1)-1);
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(kidx); 
+                               i < cidx(kidx+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[rperm[i]] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = cwork[rperm[i]];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          octave_idx_type iidx = perm[k];
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(iidx+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(iidx); 
+                                   i < cidx(iidx+1)-1; i++)
+                                {
+                                  octave_idx_type idx2 = ridx(i);
+                                  work[idx2] = work[idx2] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    cwork[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    cwork[b.ridx(i)] = b.data(i);
+
+                  for (octave_idx_type k = nc-1; k >= 0; k--)
+                    {
+                      if (cwork[k] != 0.)
+                        {
+                          if (ridx(cidx(k+1)-1) != k ||
+                              data(cidx(k+1)-1) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(cidx(k+1)-1);
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = cwork[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k >= 0; k--)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k+1)-1);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1)-1; i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = 0; i < j+1; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -2699,9 +2699,9 @@
 
 Matrix
 SparseMatrix::ltsolve (MatrixType &mattype, const Matrix& b,
-		       octave_idx_type& err, double& rcond,
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond,
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   Matrix retval;
 
@@ -2722,236 +2722,236 @@
       mattype.info ();
       
       if (typ == MatrixType::Permuted_Lower ||
-	  typ == MatrixType::Lower)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  octave_idx_type b_nc = b.cols ();
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  if (typ == MatrixType::Permuted_Lower)
-	    {
-	      retval.resize (nc, b_nc);
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-	      octave_idx_type *perm = mattype.triangular_perm ();
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  if (nc > nr)
-		    for (octave_idx_type i = 0; i < nm; i++)
-		      work[i] = 0.;
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    work[perm[i]] = b(i,j);
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (work[k] != 0.)
-			{
-			  octave_idx_type minr = nr;
-			  octave_idx_type mini = 0;
-
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    if (perm[ridx(i)] < minr)
-			      {
-				minr = perm[ridx(i)];
-				mini = i;
-			      }
-
-			  if (minr != k || data(mini) == 0)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(mini);
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    {
-			      if (i == mini)
-				continue;
-
-			      octave_idx_type iidx = perm[ridx(i)];
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval (i, j) = work[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = 0; k < nc; k++)
-			{
-			  if (work[k] != 0.)
-			    {
-			      octave_idx_type minr = nr;
-			      octave_idx_type mini = 0;
-
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				if (perm[ridx(i)] < minr)
-				  {
-				    minr = perm[ridx(i)];
-				    mini = i;
-				  }
-
-			      double tmp = work[k] / data(mini);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				{
-				  if (i == mini)
-				    continue;
-
-				  octave_idx_type iidx = perm[ridx(i)];
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-	      retval.resize (nc, b_nc, 0.);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    work[i] = b(i,j);
-		  for (octave_idx_type i = nr; i < nc; i++)
-		    work[i] = 0.;
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (work[k] != 0.)
-			{
-			  if (ridx(cidx(k)) != k ||
-			      data(cidx(k)) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(cidx(k));
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(k)+1; 
-			       i < cidx(k+1); i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval.xelem (i, j) = work[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k < nc; k++)
-			{
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k));
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k)+1; 
-				   i < cidx(k+1); i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Lower)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          octave_idx_type b_nc = b.cols ();
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          if (typ == MatrixType::Permuted_Lower)
+            {
+              retval.resize (nc, b_nc);
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+              octave_idx_type *perm = mattype.triangular_perm ();
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  if (nc > nr)
+                    for (octave_idx_type i = 0; i < nm; i++)
+                      work[i] = 0.;
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    work[perm[i]] = b(i,j);
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (work[k] != 0.)
+                        {
+                          octave_idx_type minr = nr;
+                          octave_idx_type mini = 0;
+
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            if (perm[ridx(i)] < minr)
+                              {
+                                minr = perm[ridx(i)];
+                                mini = i;
+                              }
+
+                          if (minr != k || data(mini) == 0)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(mini);
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            {
+                              if (i == mini)
+                                continue;
+
+                              octave_idx_type iidx = perm[ridx(i)];
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval (i, j) = work[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = 0; k < nc; k++)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              octave_idx_type minr = nr;
+                              octave_idx_type mini = 0;
+
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                if (perm[ridx(i)] < minr)
+                                  {
+                                    minr = perm[ridx(i)];
+                                    mini = i;
+                                  }
+
+                              double tmp = work[k] / data(mini);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                {
+                                  if (i == mini)
+                                    continue;
+
+                                  octave_idx_type iidx = perm[ridx(i)];
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+              retval.resize (nc, b_nc, 0.);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    work[i] = b(i,j);
+                  for (octave_idx_type i = nr; i < nc; i++)
+                    work[i] = 0.;
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (work[k] != 0.)
+                        {
+                          if (ridx(cidx(k)) != k ||
+                              data(cidx(k)) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(cidx(k));
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(k)+1; 
+                               i < cidx(k+1); i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval.xelem (i, j) = work[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k < nc; k++)
+                        {
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k));
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k)+1; 
+                                   i < cidx(k+1); i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -2959,9 +2959,9 @@
 
 SparseMatrix
 SparseMatrix::ltsolve (MatrixType &mattype, const SparseMatrix& b, 
-		       octave_idx_type& err, double& rcond, 
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond, 
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   SparseMatrix retval;
 
@@ -2982,283 +2982,283 @@
       mattype.info ();
       
       if (typ == MatrixType::Permuted_Lower ||
-	  typ == MatrixType::Lower)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  octave_idx_type b_nc = b.cols ();
-	  octave_idx_type b_nz = b.nnz ();
-	  retval = SparseMatrix (nc, b_nc, b_nz);
-	  retval.xcidx(0) = 0;
-	  octave_idx_type ii = 0;
-	  octave_idx_type x_nz = b_nz;
-
-	  if (typ == MatrixType::Permuted_Lower)
-	    {
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-	      octave_idx_type *perm = mattype.triangular_perm ();
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    work[perm[b.ridx(i)]] = b.data(i);
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (work[k] != 0.)
-			{
-			  octave_idx_type minr = nr;
-			  octave_idx_type mini = 0;
-
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    if (perm[ridx(i)] < minr)
-			      {
-				minr = perm[ridx(i)];
-				mini = i;
-			      }
-
-			  if (minr != k || data(mini) == 0)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(mini);
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    {
-			      if (i == mini)
-				continue;
-
-			      octave_idx_type iidx = perm[ridx(i)];
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = work[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = 0; k < nc; k++)
-			{
-			  if (work[k] != 0.)
-			    {
-			      octave_idx_type minr = nr;
-			      octave_idx_type mini = 0;
-
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				if (perm[ridx(i)] < minr)
-				  {
-				    minr = perm[ridx(i)];
-				    mini = i;
-				  }
-
-			      double tmp = work[k] / data(mini);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				{
-				  if (i == mini)
-				    continue;
-
-				  octave_idx_type iidx = perm[ridx(i)];
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nr; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (double, work, nm);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    work[b.ridx(i)] = b.data(i);
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (work[k] != 0.)
-			{
-			  if (ridx(cidx(k)) != k ||
-			      data(cidx(k)) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  double tmp = work[k] / data(cidx(k));
-			  work[k] = tmp;
-			  for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      work[iidx] = work[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (work[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = work[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k < nc; k++)
-			{
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k));
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k)+1; 
-				   i < cidx(k+1); i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Lower)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          octave_idx_type b_nc = b.cols ();
+          octave_idx_type b_nz = b.nnz ();
+          retval = SparseMatrix (nc, b_nc, b_nz);
+          retval.xcidx(0) = 0;
+          octave_idx_type ii = 0;
+          octave_idx_type x_nz = b_nz;
+
+          if (typ == MatrixType::Permuted_Lower)
+            {
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+              octave_idx_type *perm = mattype.triangular_perm ();
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    work[perm[b.ridx(i)]] = b.data(i);
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (work[k] != 0.)
+                        {
+                          octave_idx_type minr = nr;
+                          octave_idx_type mini = 0;
+
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            if (perm[ridx(i)] < minr)
+                              {
+                                minr = perm[ridx(i)];
+                                mini = i;
+                              }
+
+                          if (minr != k || data(mini) == 0)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(mini);
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            {
+                              if (i == mini)
+                                continue;
+
+                              octave_idx_type iidx = perm[ridx(i)];
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = work[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = 0; k < nc; k++)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              octave_idx_type minr = nr;
+                              octave_idx_type mini = 0;
+
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                if (perm[ridx(i)] < minr)
+                                  {
+                                    minr = perm[ridx(i)];
+                                    mini = i;
+                                  }
+
+                              double tmp = work[k] / data(mini);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                {
+                                  if (i == mini)
+                                    continue;
+
+                                  octave_idx_type iidx = perm[ridx(i)];
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nr; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (double, work, nm);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    work[b.ridx(i)] = b.data(i);
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (work[k] != 0.)
+                        {
+                          if (ridx(cidx(k)) != k ||
+                              data(cidx(k)) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          double tmp = work[k] / data(cidx(k));
+                          work[k] = tmp;
+                          for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              work[iidx] = work[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (work[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = work[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k < nc; k++)
+                        {
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k));
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k)+1; 
+                                   i < cidx(k+1); i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -3266,9 +3266,9 @@
 
 ComplexMatrix
 SparseMatrix::ltsolve (MatrixType &mattype, const ComplexMatrix& b, 
-		       octave_idx_type& err, double& rcond, 
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond, 
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   ComplexMatrix retval;
 
@@ -3289,237 +3289,237 @@
       mattype.info ();
       
       if (typ == MatrixType::Permuted_Lower ||
-	  typ == MatrixType::Lower)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  octave_idx_type b_nc = b.cols ();
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  if (typ == MatrixType::Permuted_Lower)
-	    {
-	      retval.resize (nc, b_nc);
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-	      octave_idx_type *perm = mattype.triangular_perm ();
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    cwork[i] = 0.;
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    cwork[perm[i]] = b(i,j);
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (cwork[k] != 0.)
-			{
-			  octave_idx_type minr = nr;
-			  octave_idx_type mini = 0;
-
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    if (perm[ridx(i)] < minr)
-			      {
-				minr = perm[ridx(i)];
-				mini = i;
-			      }
-
-			  if (minr != k || data(mini) == 0)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(mini);
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    {
-			      if (i == mini)
-				continue;
-
-			      octave_idx_type iidx = perm[ridx(i)];
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval (i, j) = cwork[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = 0; k < nc; k++)
-			{
-			  if (work[k] != 0.)
-			    {
-			      octave_idx_type minr = nr;
-			      octave_idx_type mini = 0;
-
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				if (perm[ridx(i)] < minr)
-				  {
-				    minr = perm[ridx(i)];
-				    mini = i;
-				  }
-
-			      double tmp = work[k] / data(mini);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				{
-				  if (i == mini)
-				    continue;
-
-				  octave_idx_type iidx = perm[ridx(i)];
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-	      retval.resize (nc, b_nc, 0.);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    cwork[i] = b(i,j);
-		  for (octave_idx_type i = nr; i < nc; i++)
-		    cwork[i] = 0.;
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (cwork[k] != 0.)
-			{
-			  if (ridx(cidx(k)) != k ||
-			      data(cidx(k)) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(cidx(k));
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    retval.xelem (i, j) = cwork[i];
-		}
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k < nc; k++)
-			{
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k));
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k)+1; 
-				   i < cidx(k+1); i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Lower)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          octave_idx_type b_nc = b.cols ();
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          if (typ == MatrixType::Permuted_Lower)
+            {
+              retval.resize (nc, b_nc);
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+              octave_idx_type *perm = mattype.triangular_perm ();
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    cwork[i] = 0.;
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    cwork[perm[i]] = b(i,j);
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (cwork[k] != 0.)
+                        {
+                          octave_idx_type minr = nr;
+                          octave_idx_type mini = 0;
+
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            if (perm[ridx(i)] < minr)
+                              {
+                                minr = perm[ridx(i)];
+                                mini = i;
+                              }
+
+                          if (minr != k || data(mini) == 0)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(mini);
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            {
+                              if (i == mini)
+                                continue;
+
+                              octave_idx_type iidx = perm[ridx(i)];
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval (i, j) = cwork[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = 0; k < nc; k++)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              octave_idx_type minr = nr;
+                              octave_idx_type mini = 0;
+
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                if (perm[ridx(i)] < minr)
+                                  {
+                                    minr = perm[ridx(i)];
+                                    mini = i;
+                                  }
+
+                              double tmp = work[k] / data(mini);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                {
+                                  if (i == mini)
+                                    continue;
+
+                                  octave_idx_type iidx = perm[ridx(i)];
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+              retval.resize (nc, b_nc, 0.);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    cwork[i] = b(i,j);
+                  for (octave_idx_type i = nr; i < nc; i++)
+                    cwork[i] = 0.;
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (cwork[k] != 0.)
+                        {
+                          if (ridx(cidx(k)) != k ||
+                              data(cidx(k)) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(cidx(k));
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    retval.xelem (i, j) = cwork[i];
+                }
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k < nc; k++)
+                        {
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k));
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k)+1; 
+                                   i < cidx(k+1); i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -3527,9 +3527,9 @@
 
 SparseComplexMatrix
 SparseMatrix::ltsolve (MatrixType &mattype, const SparseComplexMatrix& b,
-		       octave_idx_type& err, double& rcond, 
-		       solve_singularity_handler sing_handler,
-		       bool calc_cond) const
+                       octave_idx_type& err, double& rcond, 
+                       solve_singularity_handler sing_handler,
+                       bool calc_cond) const
 {
   SparseComplexMatrix retval;
 
@@ -3550,285 +3550,285 @@
       mattype.info ();
       
       if (typ == MatrixType::Permuted_Lower ||
-	  typ == MatrixType::Lower)
-	{
-	  double anorm = 0.;
-	  double ainvnorm = 0.;
-	  rcond = 1.;
-
-	  if (calc_cond)
-	    {
-	      // Calculate the 1-norm of matrix for rcond calculation
-	      for (octave_idx_type j = 0; j < nc; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  octave_idx_type b_nc = b.cols ();
-	  octave_idx_type b_nz = b.nnz ();
-	  retval = SparseComplexMatrix (nc, b_nc, b_nz);
-	  retval.xcidx(0) = 0;
-	  octave_idx_type ii = 0;
-	  octave_idx_type x_nz = b_nz;
-
-	  if (typ == MatrixType::Permuted_Lower)
-	    {
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-	      octave_idx_type *perm = mattype.triangular_perm ();
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    cwork[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    cwork[perm[b.ridx(i)]] = b.data(i);
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (cwork[k] != 0.)
-			{
-			  octave_idx_type minr = nr;
-			  octave_idx_type mini = 0;
-
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    if (perm[ridx(i)] < minr)
-			      {
-				minr = perm[ridx(i)];
-				mini = i;
-			      }
-
-			  if (minr != k || data(mini) == 0)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(mini);
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
-			    {
-			      if (i == mini)
-				continue;
-
-			      octave_idx_type iidx = perm[ridx(i)];
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = cwork[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = 0; k < nc; k++)
-			{
-			  if (work[k] != 0.)
-			    {
-			      octave_idx_type minr = nr;
-			      octave_idx_type mini = 0;
-
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				if (perm[ridx(i)] < minr)
-				  {
-				    minr = perm[ridx(i)];
-				    mini = i;
-				  }
-
-			      double tmp = work[k] / data(mini);
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k); 
-				   i < cidx(k+1); i++)
-				{
-				  if (i == mini)
-				    continue;
-
-				  octave_idx_type iidx = perm[ridx(i)];
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-	  else
-	    {
-	      OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
-
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    cwork[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    cwork[b.ridx(i)] = b.data(i);
-
-		  for (octave_idx_type k = 0; k < nc; k++)
-		    {
-		      if (cwork[k] != 0.)
-			{
-			  if (ridx(cidx(k)) != k ||
-			      data(cidx(k)) == 0.)
-			    {
-			      err = -2;
-			      goto triangular_error;
-			    }			    
-
-			  Complex tmp = cwork[k] / data(cidx(k));
-			  cwork[k] = tmp;
-			  for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
-			    {
-			      octave_idx_type iidx = ridx(i);
-			      cwork[iidx] = cwork[iidx] - tmp * data(i);
-			    }
-			}
-		    }
-
-		  // Count non-zeros in work vector and adjust space in
-		  // retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nc; i++)
-		    if (cwork[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = cwork[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      if (calc_cond)
-		{
-		  // Calculation of 1-norm of inv(*this)
-		  OCTAVE_LOCAL_BUFFER (double, work, nm);
-		  for (octave_idx_type i = 0; i < nm; i++)
-		    work[i] = 0.;
-
-		  for (octave_idx_type j = 0; j < nr; j++)
-		    {
-		      work[j] = 1.;
-
-		      for (octave_idx_type k = j; k < nc; k++)
-			{
-
-			  if (work[k] != 0.)
-			    {
-			      double tmp = work[k] / data(cidx(k));
-			      work[k] = tmp;
-			      for (octave_idx_type i = cidx(k)+1; 
-				   i < cidx(k+1); i++)
-				{
-				  octave_idx_type iidx = ridx(i);
-				  work[iidx] = work[iidx] - tmp * data(i);
-				}
-			    }
-			}
-		      double atmp = 0;
-		      for (octave_idx_type i = j; i < nc; i++)
-			{
-			  atmp += fabs(work[i]);
-			  work[i] = 0.;
-			}
-		      if (atmp > ainvnorm)
-			ainvnorm = atmp;
-		    }
-		  rcond = 1. / ainvnorm / anorm;
-		}
-	    }
-
-	triangular_error:
-	  if (err != 0)
-	    {
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-
-	  volatile double rcond_plus_one = rcond + 1.0;
-
-	  if (rcond_plus_one == 1.0 || xisnan (rcond))
-	    {
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision, rcond = %g",
-		   rcond);
-	    }
-	}
+          typ == MatrixType::Lower)
+        {
+          double anorm = 0.;
+          double ainvnorm = 0.;
+          rcond = 1.;
+
+          if (calc_cond)
+            {
+              // Calculate the 1-norm of matrix for rcond calculation
+              for (octave_idx_type j = 0; j < nc; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          octave_idx_type b_nc = b.cols ();
+          octave_idx_type b_nz = b.nnz ();
+          retval = SparseComplexMatrix (nc, b_nc, b_nz);
+          retval.xcidx(0) = 0;
+          octave_idx_type ii = 0;
+          octave_idx_type x_nz = b_nz;
+
+          if (typ == MatrixType::Permuted_Lower)
+            {
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+              octave_idx_type *perm = mattype.triangular_perm ();
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    cwork[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    cwork[perm[b.ridx(i)]] = b.data(i);
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (cwork[k] != 0.)
+                        {
+                          octave_idx_type minr = nr;
+                          octave_idx_type mini = 0;
+
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            if (perm[ridx(i)] < minr)
+                              {
+                                minr = perm[ridx(i)];
+                                mini = i;
+                              }
+
+                          if (minr != k || data(mini) == 0)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(mini);
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+                            {
+                              if (i == mini)
+                                continue;
+
+                              octave_idx_type iidx = perm[ridx(i)];
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = cwork[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = 0; k < nc; k++)
+                        {
+                          if (work[k] != 0.)
+                            {
+                              octave_idx_type minr = nr;
+                              octave_idx_type mini = 0;
+
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                if (perm[ridx(i)] < minr)
+                                  {
+                                    minr = perm[ridx(i)];
+                                    mini = i;
+                                  }
+
+                              double tmp = work[k] / data(mini);
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k); 
+                                   i < cidx(k+1); i++)
+                                {
+                                  if (i == mini)
+                                    continue;
+
+                                  octave_idx_type iidx = perm[ridx(i)];
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+          else
+            {
+              OCTAVE_LOCAL_BUFFER (Complex, cwork, nm);
+
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    cwork[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    cwork[b.ridx(i)] = b.data(i);
+
+                  for (octave_idx_type k = 0; k < nc; k++)
+                    {
+                      if (cwork[k] != 0.)
+                        {
+                          if (ridx(cidx(k)) != k ||
+                              data(cidx(k)) == 0.)
+                            {
+                              err = -2;
+                              goto triangular_error;
+                            }                       
+
+                          Complex tmp = cwork[k] / data(cidx(k));
+                          cwork[k] = tmp;
+                          for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+                            {
+                              octave_idx_type iidx = ridx(i);
+                              cwork[iidx] = cwork[iidx] - tmp * data(i);
+                            }
+                        }
+                    }
+
+                  // Count non-zeros in work vector and adjust space in
+                  // retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nc; i++)
+                    if (cwork[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = cwork[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              if (calc_cond)
+                {
+                  // Calculation of 1-norm of inv(*this)
+                  OCTAVE_LOCAL_BUFFER (double, work, nm);
+                  for (octave_idx_type i = 0; i < nm; i++)
+                    work[i] = 0.;
+
+                  for (octave_idx_type j = 0; j < nr; j++)
+                    {
+                      work[j] = 1.;
+
+                      for (octave_idx_type k = j; k < nc; k++)
+                        {
+
+                          if (work[k] != 0.)
+                            {
+                              double tmp = work[k] / data(cidx(k));
+                              work[k] = tmp;
+                              for (octave_idx_type i = cidx(k)+1; 
+                                   i < cidx(k+1); i++)
+                                {
+                                  octave_idx_type iidx = ridx(i);
+                                  work[iidx] = work[iidx] - tmp * data(i);
+                                }
+                            }
+                        }
+                      double atmp = 0;
+                      for (octave_idx_type i = j; i < nc; i++)
+                        {
+                          atmp += fabs(work[i]);
+                          work[i] = 0.;
+                        }
+                      if (atmp > ainvnorm)
+                        ainvnorm = atmp;
+                    }
+                  rcond = 1. / ainvnorm / anorm;
+                }
+            }
+
+        triangular_error:
+          if (err != 0)
+            {
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+
+          volatile double rcond_plus_one = rcond + 1.0;
+
+          if (rcond_plus_one == 1.0 || xisnan (rcond))
+            {
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision, rcond = %g",
+                   rcond);
+            }
+        }
       else
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -3836,9 +3836,9 @@
 
 Matrix
 SparseMatrix::trisolve (MatrixType &mattype, const Matrix& b,
-			octave_idx_type& err, double& rcond,
-			solve_singularity_handler sing_handler,
-			bool calc_cond) const
+                        octave_idx_type& err, double& rcond,
+                        solve_singularity_handler sing_handler,
+                        bool calc_cond) const
 {
   Matrix retval;
 
@@ -3861,125 +3861,125 @@
       mattype.info ();
       
       if (typ == MatrixType::Tridiagonal_Hermitian)
-	{
-	  OCTAVE_LOCAL_BUFFER (double, D, nr);
-	  OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
-
-	  if (mattype.is_dense ())
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < nc-1; j++)
-		{
-		  D[j] = data(ii++);
-		  DL[j] = data(ii);
-		  ii += 2;
-		}
-	      D[nc-1] = data(ii);
-	    }
-	  else
-	    {
-	      D[0] = 0.;
-	      for (octave_idx_type i = 0; i < nr - 1; i++)
-		{
-		  D[i+1] = 0.;
-		  DL[i] = 0.;
-		}
-
-	      for (octave_idx_type j = 0; j < nc; j++)
-		for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		  {
-		    if (ridx(i) == j)
-		      D[j] = data(i);
-		    else if (ridx(i) == j + 1)
-		      DL[j] = data(i);
-		  }
-	    }
-	      
-	  octave_idx_type b_nc = b.cols();
-	  retval = b;
-	  double *result = retval.fortran_vec ();
-
-	  F77_XFCN (dptsv, DPTSV, (nr, b_nc, D, DL, result, 
-				   b.rows(), err));
-
-	  if (err != 0)
-	    {
-	      err = 0;
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Tridiagonal;
-	    }
-	  else 
-	    rcond = 1.;
-	}
+        {
+          OCTAVE_LOCAL_BUFFER (double, D, nr);
+          OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
+
+          if (mattype.is_dense ())
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < nc-1; j++)
+                {
+                  D[j] = data(ii++);
+                  DL[j] = data(ii);
+                  ii += 2;
+                }
+              D[nc-1] = data(ii);
+            }
+          else
+            {
+              D[0] = 0.;
+              for (octave_idx_type i = 0; i < nr - 1; i++)
+                {
+                  D[i+1] = 0.;
+                  DL[i] = 0.;
+                }
+
+              for (octave_idx_type j = 0; j < nc; j++)
+                for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                  {
+                    if (ridx(i) == j)
+                      D[j] = data(i);
+                    else if (ridx(i) == j + 1)
+                      DL[j] = data(i);
+                  }
+            }
+              
+          octave_idx_type b_nc = b.cols();
+          retval = b;
+          double *result = retval.fortran_vec ();
+
+          F77_XFCN (dptsv, DPTSV, (nr, b_nc, D, DL, result, 
+                                   b.rows(), err));
+
+          if (err != 0)
+            {
+              err = 0;
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Tridiagonal;
+            }
+          else 
+            rcond = 1.;
+        }
 
       if (typ == MatrixType::Tridiagonal)
-	{
-	  OCTAVE_LOCAL_BUFFER (double, DU, nr - 1);
-	  OCTAVE_LOCAL_BUFFER (double, D, nr);
-	  OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
-
-	  if (mattype.is_dense ())
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < nc-1; j++)
-		{
-		  D[j] = data(ii++);
-		  DL[j] = data(ii++);
-		  DU[j] = data(ii++);
-		}
-	      D[nc-1] = data(ii);
-	    }
-	  else
-	    {
-	      D[0] = 0.;
-	      for (octave_idx_type i = 0; i < nr - 1; i++)
-		{
-		  D[i+1] = 0.;
-		  DL[i] = 0.;
-		  DU[i] = 0.;
-		}
-
-	      for (octave_idx_type j = 0; j < nc; j++)
-		for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		  {
-		    if (ridx(i) == j)
-		      D[j] = data(i);
-		    else if (ridx(i) == j + 1)
-		      DL[j] = data(i);
-		    else if (ridx(i) == j - 1)
-		      DU[j-1] = data(i);
-		  }
-	    }
-
-	  octave_idx_type b_nc = b.cols();
-	  retval = b;
-	  double *result = retval.fortran_vec ();
-
-	  F77_XFCN (dgtsv, DGTSV, (nr, b_nc, DL, D, DU, result, 
-				   b.rows(), err));
-
-	  if (err != 0)
-	    {
-	      rcond = 0.;
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-
-	    } 
-	  else 
-	    rcond = 1.;
-	}
+        {
+          OCTAVE_LOCAL_BUFFER (double, DU, nr - 1);
+          OCTAVE_LOCAL_BUFFER (double, D, nr);
+          OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
+
+          if (mattype.is_dense ())
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < nc-1; j++)
+                {
+                  D[j] = data(ii++);
+                  DL[j] = data(ii++);
+                  DU[j] = data(ii++);
+                }
+              D[nc-1] = data(ii);
+            }
+          else
+            {
+              D[0] = 0.;
+              for (octave_idx_type i = 0; i < nr - 1; i++)
+                {
+                  D[i+1] = 0.;
+                  DL[i] = 0.;
+                  DU[i] = 0.;
+                }
+
+              for (octave_idx_type j = 0; j < nc; j++)
+                for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                  {
+                    if (ridx(i) == j)
+                      D[j] = data(i);
+                    else if (ridx(i) == j + 1)
+                      DL[j] = data(i);
+                    else if (ridx(i) == j - 1)
+                      DU[j-1] = data(i);
+                  }
+            }
+
+          octave_idx_type b_nc = b.cols();
+          retval = b;
+          double *result = retval.fortran_vec ();
+
+          F77_XFCN (dgtsv, DGTSV, (nr, b_nc, DL, D, DU, result, 
+                                   b.rows(), err));
+
+          if (err != 0)
+            {
+              rcond = 0.;
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+
+            } 
+          else 
+            rcond = 1.;
+        }
       else if (typ != MatrixType::Tridiagonal_Hermitian)
-	       (*current_liboctave_error_handler) ("incorrect matrix type");
+               (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -3987,9 +3987,9 @@
 
 SparseMatrix
 SparseMatrix::trisolve (MatrixType &mattype, const SparseMatrix& b, 
-			octave_idx_type& err, double& rcond, 
-			solve_singularity_handler sing_handler,
-			bool calc_cond) const
+                        octave_idx_type& err, double& rcond, 
+                        solve_singularity_handler sing_handler,
+                        bool calc_cond) const
 {
   SparseMatrix retval;
 
@@ -4013,120 +4013,120 @@
       
       // Note can't treat symmetric case as there is no dpttrf function
       if (typ == MatrixType::Tridiagonal ||
-	  typ == MatrixType::Tridiagonal_Hermitian)
-	{
-	  OCTAVE_LOCAL_BUFFER (double, DU2, nr - 2);
-	  OCTAVE_LOCAL_BUFFER (double, DU, nr - 1);
-	  OCTAVE_LOCAL_BUFFER (double, D, nr);
-	  OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
-	  Array<octave_idx_type> ipvt (nr);
-	  octave_idx_type *pipvt = ipvt.fortran_vec ();
-
-	  if (mattype.is_dense ())
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < nc-1; j++)
-		{
-		  D[j] = data(ii++);
-		  DL[j] = data(ii++);
-		  DU[j] = data(ii++);
-		}
-	      D[nc-1] = data(ii);
-	    }
-	  else
-	    {
-	      D[0] = 0.;
-	      for (octave_idx_type i = 0; i < nr - 1; i++)
-		{
-		  D[i+1] = 0.;
-		  DL[i] = 0.;
-		  DU[i] = 0.;
-		}
-
-	      for (octave_idx_type j = 0; j < nc; j++)
-		for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		  {
-		    if (ridx(i) == j)
-		      D[j] = data(i);
-		    else if (ridx(i) == j + 1)
-		      DL[j] = data(i);
-		    else if (ridx(i) == j - 1)
-		      DU[j-1] = data(i);
-		  }
-	    }
-
-	  F77_XFCN (dgttrf, DGTTRF, (nr, DL, D, DU, DU2, pipvt, err));
-
-	  if (err != 0) 
-	    {
-	      rcond = 0.0;
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-
-	    } 
-	  else 
-	    {
-	      rcond = 1.0;
-	      char job = 'N';
-	      volatile octave_idx_type x_nz = b.nnz ();
-	      octave_idx_type b_nc = b.cols ();
-	      retval = SparseMatrix (nr, b_nc, x_nz);
-	      retval.xcidx(0) = 0;
-	      volatile octave_idx_type ii = 0;
-
-	      OCTAVE_LOCAL_BUFFER (double, work, nr);
-
-	      for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    work[i] = 0.;
-		  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
-		    work[b.ridx(i)] = b.data(i);
-
-		  F77_XFCN (dgttrs, DGTTRS, 
-			    (F77_CONST_CHAR_ARG2 (&job, 1),
-			     nr, 1, DL, D, DU, DU2, pipvt, 
-			     work, b.rows (), err
-			     F77_CHAR_ARG_LEN (1)));
-
-		  // Count non-zeros in work vector and adjust 
-		  // space in retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    if (work[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    if (work[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = work[i];
-		      }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-	    }
-	}
+          typ == MatrixType::Tridiagonal_Hermitian)
+        {
+          OCTAVE_LOCAL_BUFFER (double, DU2, nr - 2);
+          OCTAVE_LOCAL_BUFFER (double, DU, nr - 1);
+          OCTAVE_LOCAL_BUFFER (double, D, nr);
+          OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
+          Array<octave_idx_type> ipvt (nr);
+          octave_idx_type *pipvt = ipvt.fortran_vec ();
+
+          if (mattype.is_dense ())
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < nc-1; j++)
+                {
+                  D[j] = data(ii++);
+                  DL[j] = data(ii++);
+                  DU[j] = data(ii++);
+                }
+              D[nc-1] = data(ii);
+            }
+          else
+            {
+              D[0] = 0.;
+              for (octave_idx_type i = 0; i < nr - 1; i++)
+                {
+                  D[i+1] = 0.;
+                  DL[i] = 0.;
+                  DU[i] = 0.;
+                }
+
+              for (octave_idx_type j = 0; j < nc; j++)
+                for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                  {
+                    if (ridx(i) == j)
+                      D[j] = data(i);
+                    else if (ridx(i) == j + 1)
+                      DL[j] = data(i);
+                    else if (ridx(i) == j - 1)
+                      DU[j-1] = data(i);
+                  }
+            }
+
+          F77_XFCN (dgttrf, DGTTRF, (nr, DL, D, DU, DU2, pipvt, err));
+
+          if (err != 0) 
+            {
+              rcond = 0.0;
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+
+            } 
+          else 
+            {
+              rcond = 1.0;
+              char job = 'N';
+              volatile octave_idx_type x_nz = b.nnz ();
+              octave_idx_type b_nc = b.cols ();
+              retval = SparseMatrix (nr, b_nc, x_nz);
+              retval.xcidx(0) = 0;
+              volatile octave_idx_type ii = 0;
+
+              OCTAVE_LOCAL_BUFFER (double, work, nr);
+
+              for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    work[i] = 0.;
+                  for (octave_idx_type i = b.cidx(j); i < b.cidx(j+1); i++)
+                    work[b.ridx(i)] = b.data(i);
+
+                  F77_XFCN (dgttrs, DGTTRS, 
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, 1, DL, D, DU, DU2, pipvt, 
+                             work, b.rows (), err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  // Count non-zeros in work vector and adjust 
+                  // space in retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    if (work[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    if (work[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = work[i];
+                      }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+            }
+        }
       else if (typ != MatrixType::Tridiagonal_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -4134,9 +4134,9 @@
 
 ComplexMatrix
 SparseMatrix::trisolve (MatrixType &mattype, const ComplexMatrix& b, 
-			octave_idx_type& err, double& rcond, 
-			solve_singularity_handler sing_handler,
-			bool calc_cond) const
+                        octave_idx_type& err, double& rcond, 
+                        solve_singularity_handler sing_handler,
+                        bool calc_cond) const
 {
   ComplexMatrix retval;
 
@@ -4159,126 +4159,126 @@
       mattype.info ();
       
       if (typ == MatrixType::Tridiagonal_Hermitian)
-	{
-	  OCTAVE_LOCAL_BUFFER (double, D, nr);
-	  OCTAVE_LOCAL_BUFFER (Complex, DL, nr - 1);
-
-	  if (mattype.is_dense ())
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < nc-1; j++)
-		{
-		  D[j] = data(ii++);
-		  DL[j] = data(ii);
-		  ii += 2;
-		}
-	      D[nc-1] = data(ii);
-	    }
-	  else
-	    {
-	      D[0] = 0.;
-	      for (octave_idx_type i = 0; i < nr - 1; i++)
-		{
-		  D[i+1] = 0.;
-		  DL[i] = 0.;
-		}
-
-	      for (octave_idx_type j = 0; j < nc; j++)
-		for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		  {
-		    if (ridx(i) == j)
-		      D[j] = data(i);
-		    else if (ridx(i) == j + 1)
-		      DL[j] = data(i);
-		  }
-	    }
-
-	  octave_idx_type b_nr = b.rows ();
-	  octave_idx_type b_nc = b.cols();
-	  rcond = 1.;
-
-	  retval = b;
-	  Complex *result = retval.fortran_vec ();
-		  
-	  F77_XFCN (zptsv, ZPTSV, (nr, b_nc, D, DL, result, 
-				   b_nr, err));
-
-	  if (err != 0)
-	    {
-	      err = 0;
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Tridiagonal;
-	    }
-	}
+        {
+          OCTAVE_LOCAL_BUFFER (double, D, nr);
+          OCTAVE_LOCAL_BUFFER (Complex, DL, nr - 1);
+
+          if (mattype.is_dense ())
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < nc-1; j++)
+                {
+                  D[j] = data(ii++);
+                  DL[j] = data(ii);
+                  ii += 2;
+                }
+              D[nc-1] = data(ii);
+            }
+          else
+            {
+              D[0] = 0.;
+              for (octave_idx_type i = 0; i < nr - 1; i++)
+                {
+                  D[i+1] = 0.;
+                  DL[i] = 0.;
+                }
+
+              for (octave_idx_type j = 0; j < nc; j++)
+                for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                  {
+                    if (ridx(i) == j)
+                      D[j] = data(i);
+                    else if (ridx(i) == j + 1)
+                      DL[j] = data(i);
+                  }
+            }
+
+          octave_idx_type b_nr = b.rows ();
+          octave_idx_type b_nc = b.cols();
+          rcond = 1.;
+
+          retval = b;
+          Complex *result = retval.fortran_vec ();
+                  
+          F77_XFCN (zptsv, ZPTSV, (nr, b_nc, D, DL, result, 
+                                   b_nr, err));
+
+          if (err != 0)
+            {
+              err = 0;
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Tridiagonal;
+            }
+        }
 
       if (typ == MatrixType::Tridiagonal)
-	{
-	  OCTAVE_LOCAL_BUFFER (Complex, DU, nr - 1);
-	  OCTAVE_LOCAL_BUFFER (Complex, D, nr);
-	  OCTAVE_LOCAL_BUFFER (Complex, DL, nr - 1);
-
-	  if (mattype.is_dense ())
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < nc-1; j++)
-		{
-		  D[j] = data(ii++);
-		  DL[j] = data(ii++);
-		  DU[j] = data(ii++);
-		}
-	      D[nc-1] = data(ii);
-	    }
-	  else
-	    {
-	      D[0] = 0.;
-	      for (octave_idx_type i = 0; i < nr - 1; i++)
-		{
-		  D[i+1] = 0.;
-		  DL[i] = 0.;
-		  DU[i] = 0.;
-		}
-
-	      for (octave_idx_type j = 0; j < nc; j++)
-		for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		  {
-		    if (ridx(i) == j)
-		      D[j] = data(i);
-		    else if (ridx(i) == j + 1)
-		      DL[j] = data(i);
-		    else if (ridx(i) == j - 1)
-		      DU[j-1] = data(i);
-		  }
-	    }
-
-	  octave_idx_type b_nr = b.rows();
-	  octave_idx_type b_nc = b.cols();
-	  rcond = 1.;
-
-	  retval = b;
-	  Complex *result = retval.fortran_vec ();
-	      
-	  F77_XFCN (zgtsv, ZGTSV, (nr, b_nc, DL, D, DU, result, 
-				   b_nr, err));
-
-	  if (err != 0)
-	    {
-	      rcond = 0.;
-	      err = -2;
-		      
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-	    }
-	}
+        {
+          OCTAVE_LOCAL_BUFFER (Complex, DU, nr - 1);
+          OCTAVE_LOCAL_BUFFER (Complex, D, nr);
+          OCTAVE_LOCAL_BUFFER (Complex, DL, nr - 1);
+
+          if (mattype.is_dense ())
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < nc-1; j++)
+                {
+                  D[j] = data(ii++);
+                  DL[j] = data(ii++);
+                  DU[j] = data(ii++);
+                }
+              D[nc-1] = data(ii);
+            }
+          else
+            {
+              D[0] = 0.;
+              for (octave_idx_type i = 0; i < nr - 1; i++)
+                {
+                  D[i+1] = 0.;
+                  DL[i] = 0.;
+                  DU[i] = 0.;
+                }
+
+              for (octave_idx_type j = 0; j < nc; j++)
+                for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                  {
+                    if (ridx(i) == j)
+                      D[j] = data(i);
+                    else if (ridx(i) == j + 1)
+                      DL[j] = data(i);
+                    else if (ridx(i) == j - 1)
+                      DU[j-1] = data(i);
+                  }
+            }
+
+          octave_idx_type b_nr = b.rows();
+          octave_idx_type b_nc = b.cols();
+          rcond = 1.;
+
+          retval = b;
+          Complex *result = retval.fortran_vec ();
+              
+          F77_XFCN (zgtsv, ZGTSV, (nr, b_nc, DL, D, DU, result, 
+                                   b_nr, err));
+
+          if (err != 0)
+            {
+              rcond = 0.;
+              err = -2;
+                      
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+            }
+        }
       else if (typ != MatrixType::Tridiagonal_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -4286,9 +4286,9 @@
 
 SparseComplexMatrix
 SparseMatrix::trisolve (MatrixType &mattype, const SparseComplexMatrix& b,
-			octave_idx_type& err, double& rcond, 
-			solve_singularity_handler sing_handler,
-			bool calc_cond) const
+                        octave_idx_type& err, double& rcond, 
+                        solve_singularity_handler sing_handler,
+                        bool calc_cond) const
 {
   SparseComplexMatrix retval;
 
@@ -4312,152 +4312,152 @@
       
       // Note can't treat symmetric case as there is no dpttrf function
       if (typ == MatrixType::Tridiagonal ||
-	  typ == MatrixType::Tridiagonal_Hermitian)
-	{
-	  OCTAVE_LOCAL_BUFFER (double, DU2, nr - 2);
-	  OCTAVE_LOCAL_BUFFER (double, DU, nr - 1);
-	  OCTAVE_LOCAL_BUFFER (double, D, nr);
-	  OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
-	  Array<octave_idx_type> ipvt (nr);
-	  octave_idx_type *pipvt = ipvt.fortran_vec ();
-
-	  if (mattype.is_dense ())
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < nc-1; j++)
-		{
-		  D[j] = data(ii++);
-		  DL[j] = data(ii++);
-		  DU[j] = data(ii++);
-		}
-	      D[nc-1] = data(ii);
-	    }
-	  else
-	    {
-	      D[0] = 0.;
-	      for (octave_idx_type i = 0; i < nr - 1; i++)
-		{
-		  D[i+1] = 0.;
-		  DL[i] = 0.;
-		  DU[i] = 0.;
-		}
-
-	      for (octave_idx_type j = 0; j < nc; j++)
-		for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		  {
-		    if (ridx(i) == j)
-		      D[j] = data(i);
-		    else if (ridx(i) == j + 1)
-		      DL[j] = data(i);
-		    else if (ridx(i) == j - 1)
-		      DU[j-1] = data(i);
-		  }
-	    }
-
-	  F77_XFCN (dgttrf, DGTTRF, (nr, DL, D, DU, DU2, pipvt, err));
-
-	  if (err != 0) 
-	    {
-	      rcond = 0.0;
-	      err = -2;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-	    } 
-	  else 
-	    {	
-	      rcond = 1.;
-	      char job = 'N';
-	      octave_idx_type b_nr = b.rows ();
-	      octave_idx_type b_nc = b.cols ();
-	      OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-	      OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
-
-	      // Take a first guess that the number of non-zero terms
-	      // will be as many as in b
-	      volatile octave_idx_type x_nz = b.nnz ();
-	      volatile octave_idx_type ii = 0;
-	      retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
-
-	      retval.xcidx(0) = 0;
-	      for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		{
-
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    {
-		      Complex c = b (i,j);
-		      Bx[i] = std::real (c);
-		      Bz[i] = std::imag (c);
-		    }
-
-		  F77_XFCN (dgttrs, DGTTRS, 
-			    (F77_CONST_CHAR_ARG2 (&job, 1),
-			     nr, 1, DL, D, DU, DU2, pipvt, 
-			     Bx, b_nr, err
-			     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0)
-		    {
-		      (*current_liboctave_error_handler)
-			("SparseMatrix::solve solve failed");
-
-		      err = -1;
-		      break;
-		    }
-
-		  F77_XFCN (dgttrs, DGTTRS, 
-			    (F77_CONST_CHAR_ARG2 (&job, 1),
-			     nr, 1, DL, D, DU, DU2, pipvt, 
-			     Bz, b_nr, err
-			     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0)
-		    {
-		      (*current_liboctave_error_handler)
-			("SparseMatrix::solve solve failed");
-
-		      err = -1;
-		      break;
-		    }
-
-		  // Count non-zeros in work vector and adjust 
-		  // space in retval if needed
-		  octave_idx_type new_nnz = 0;
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    if (Bx[i] != 0. || Bz[i] != 0.)
-		      new_nnz++;
-
-		  if (ii + new_nnz > x_nz)
-		    {
-		      // Resize the sparse matrix
-		      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-		      retval.change_capacity (sz);
-		      x_nz = sz;
-		    }
-
-		  for (octave_idx_type i = 0; i < nr; i++)
-		    if (Bx[i] != 0. || Bz[i] != 0.)
-		      {
-			retval.xridx(ii) = i;
-			retval.xdata(ii++) = 
-			  Complex (Bx[i], Bz[i]);
-		      }
-
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-	    }
-	}
+          typ == MatrixType::Tridiagonal_Hermitian)
+        {
+          OCTAVE_LOCAL_BUFFER (double, DU2, nr - 2);
+          OCTAVE_LOCAL_BUFFER (double, DU, nr - 1);
+          OCTAVE_LOCAL_BUFFER (double, D, nr);
+          OCTAVE_LOCAL_BUFFER (double, DL, nr - 1);
+          Array<octave_idx_type> ipvt (nr);
+          octave_idx_type *pipvt = ipvt.fortran_vec ();
+
+          if (mattype.is_dense ())
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < nc-1; j++)
+                {
+                  D[j] = data(ii++);
+                  DL[j] = data(ii++);
+                  DU[j] = data(ii++);
+                }
+              D[nc-1] = data(ii);
+            }
+          else
+            {
+              D[0] = 0.;
+              for (octave_idx_type i = 0; i < nr - 1; i++)
+                {
+                  D[i+1] = 0.;
+                  DL[i] = 0.;
+                  DU[i] = 0.;
+                }
+
+              for (octave_idx_type j = 0; j < nc; j++)
+                for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                  {
+                    if (ridx(i) == j)
+                      D[j] = data(i);
+                    else if (ridx(i) == j + 1)
+                      DL[j] = data(i);
+                    else if (ridx(i) == j - 1)
+                      DU[j-1] = data(i);
+                  }
+            }
+
+          F77_XFCN (dgttrf, DGTTRF, (nr, DL, D, DU, DU2, pipvt, err));
+
+          if (err != 0) 
+            {
+              rcond = 0.0;
+              err = -2;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+            } 
+          else 
+            {   
+              rcond = 1.;
+              char job = 'N';
+              octave_idx_type b_nr = b.rows ();
+              octave_idx_type b_nc = b.cols ();
+              OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+              OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
+
+              // Take a first guess that the number of non-zero terms
+              // will be as many as in b
+              volatile octave_idx_type x_nz = b.nnz ();
+              volatile octave_idx_type ii = 0;
+              retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
+
+              retval.xcidx(0) = 0;
+              for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                {
+
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    {
+                      Complex c = b (i,j);
+                      Bx[i] = std::real (c);
+                      Bz[i] = std::imag (c);
+                    }
+
+                  F77_XFCN (dgttrs, DGTTRS, 
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, 1, DL, D, DU, DU2, pipvt, 
+                             Bx, b_nr, err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
+                    {
+                      (*current_liboctave_error_handler)
+                        ("SparseMatrix::solve solve failed");
+
+                      err = -1;
+                      break;
+                    }
+
+                  F77_XFCN (dgttrs, DGTTRS, 
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, 1, DL, D, DU, DU2, pipvt, 
+                             Bz, b_nr, err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
+                    {
+                      (*current_liboctave_error_handler)
+                        ("SparseMatrix::solve solve failed");
+
+                      err = -1;
+                      break;
+                    }
+
+                  // Count non-zeros in work vector and adjust 
+                  // space in retval if needed
+                  octave_idx_type new_nnz = 0;
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    if (Bx[i] != 0. || Bz[i] != 0.)
+                      new_nnz++;
+
+                  if (ii + new_nnz > x_nz)
+                    {
+                      // Resize the sparse matrix
+                      octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                      retval.change_capacity (sz);
+                      x_nz = sz;
+                    }
+
+                  for (octave_idx_type i = 0; i < nr; i++)
+                    if (Bx[i] != 0. || Bz[i] != 0.)
+                      {
+                        retval.xridx(ii) = i;
+                        retval.xdata(ii++) = 
+                          Complex (Bx[i], Bz[i]);
+                      }
+
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+            }
+        }
       else if (typ != MatrixType::Tridiagonal_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -4465,9 +4465,9 @@
 
 Matrix
 SparseMatrix::bsolve (MatrixType &mattype, const Matrix& b,
-		      octave_idx_type& err, double& rcond,
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond,
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   Matrix retval;
 
@@ -4487,226 +4487,226 @@
       mattype.info ();
 
       if (typ == MatrixType::Banded_Hermitian)
-	{
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_lower + 1;
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      {
-		octave_idx_type ri = ridx (i);
-		if (ri >= j)
-		  m_band(ri - j, j) = data(i);
-	      }
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    anorm = m_band.abs().sum().row(0).max();
-
-	  char job = 'L';
-	  F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
-				     nr, n_lower, tmp_data, ldm, err
-				     F77_CHAR_ARG_LEN (1)));
-	    
-	  if (err != 0) 
-	    {
-	      // Matrix is not positive definite!! Fall through to
-	      // unsymmetric banded solver.
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Banded;
-	      rcond = 0.0;
-	      err = 0;
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dpbcon, DPBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nr, n_lower, tmp_data, ldm,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  retval = b;
-		  double *result = retval.fortran_vec ();
-
-		  octave_idx_type b_nc = b.cols ();
-
-		  F77_XFCN (dpbtrs, DPBTRS, 
-			    (F77_CONST_CHAR_ARG2 (&job, 1),
-			     nr, n_lower, b_nc, tmp_data,
-			     ldm, result, b.rows(), err
-			     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0)
-		    {
-		      (*current_liboctave_error_handler) 
-			("SparseMatrix::solve solve failed");
-		      err = -1;
-		    }
-		}
-	    }
-	}
+        {
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_lower + 1;
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              {
+                octave_idx_type ri = ridx (i);
+                if (ri >= j)
+                  m_band(ri - j, j) = data(i);
+              }
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            anorm = m_band.abs().sum().row(0).max();
+
+          char job = 'L';
+          F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                     nr, n_lower, tmp_data, ldm, err
+                                     F77_CHAR_ARG_LEN (1)));
+            
+          if (err != 0) 
+            {
+              // Matrix is not positive definite!! Fall through to
+              // unsymmetric banded solver.
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Banded;
+              rcond = 0.0;
+              err = 0;
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dpbcon, DPBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nr, n_lower, tmp_data, ldm,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  retval = b;
+                  double *result = retval.fortran_vec ();
+
+                  octave_idx_type b_nc = b.cols ();
+
+                  F77_XFCN (dpbtrs, DPBTRS, 
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, n_lower, b_nc, tmp_data,
+                             ldm, result, b.rows(), err
+                             F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0)
+                    {
+                      (*current_liboctave_error_handler) 
+                        ("SparseMatrix::solve solve failed");
+                      err = -1;
+                    }
+                }
+            }
+        }
 
       if (typ == MatrixType::Banded)
-	{
-	  // Create the storage for the banded form of the sparse matrix
-	  octave_idx_type n_upper = mattype.nupper ();
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_upper + 2 * n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    {
-	      for (octave_idx_type j = 0; j < nr; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  Array<octave_idx_type> ipvt (nr);
-	  octave_idx_type *pipvt = ipvt.fortran_vec ();
-
-	  F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
-				     ldm, pipvt, err));
-	    
-	  // Throw-away extra info LAPACK gives so as to not 
-	  // change output.
-	  if (err != 0) 
-	    {
-	      err = -2;
-	      rcond = 0.0;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  char job = '1';
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dgbcon, DGBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		   if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  retval = b;
-		  double *result = retval.fortran_vec ();
-
-		  octave_idx_type b_nc = b.cols ();
-
-		  char job = 'N';
-		  F77_XFCN (dgbtrs, DGBTRS, 
-			    (F77_CONST_CHAR_ARG2 (&job, 1),
-			     nr, n_lower, n_upper, b_nc, tmp_data,
-			     ldm, pipvt, result, b.rows(), err
-			     F77_CHAR_ARG_LEN (1)));
-		}
-	    }
-	}
+        {
+          // Create the storage for the banded form of the sparse matrix
+          octave_idx_type n_upper = mattype.nupper ();
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_upper + 2 * n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            {
+              for (octave_idx_type j = 0; j < nr; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          Array<octave_idx_type> ipvt (nr);
+          octave_idx_type *pipvt = ipvt.fortran_vec ();
+
+          F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
+                                     ldm, pipvt, err));
+            
+          // Throw-away extra info LAPACK gives so as to not 
+          // change output.
+          if (err != 0) 
+            {
+              err = -2;
+              rcond = 0.0;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  char job = '1';
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dgbcon, DGBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                   if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  retval = b;
+                  double *result = retval.fortran_vec ();
+
+                  octave_idx_type b_nc = b.cols ();
+
+                  char job = 'N';
+                  F77_XFCN (dgbtrs, DGBTRS, 
+                            (F77_CONST_CHAR_ARG2 (&job, 1),
+                             nr, n_lower, n_upper, b_nc, tmp_data,
+                             ldm, pipvt, result, b.rows(), err
+                             F77_CHAR_ARG_LEN (1)));
+                }
+            }
+        }
       else if (typ != MatrixType::Banded_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -4714,9 +4714,9 @@
 
 SparseMatrix
 SparseMatrix::bsolve (MatrixType &mattype, const SparseMatrix& b,
-		      octave_idx_type& err, double& rcond, 
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond, 
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   SparseMatrix retval;
 
@@ -4736,295 +4736,295 @@
       mattype.info ();
 
       if (typ == MatrixType::Banded_Hermitian)
-	{
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      {
-		octave_idx_type ri = ridx (i);
-		if (ri >= j)
-		  m_band(ri - j, j) = data(i);
-	      }
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    anorm = m_band.abs().sum().row(0).max();
-
-	  char job = 'L';
-	  F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
-				     nr, n_lower, tmp_data, ldm, err
-				     F77_CHAR_ARG_LEN (1)));
-	    
-	  if (err != 0) 
-	    {
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Banded;
-	      rcond = 0.0;
-	      err = 0;
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dpbcon, DPBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nr, n_lower, tmp_data, ldm,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  octave_idx_type b_nr = b.rows ();
-		  octave_idx_type b_nc = b.cols ();
-		  OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-
-		  // Take a first guess that the number of non-zero terms
-		  // will be as many as in b
-		  volatile octave_idx_type x_nz = b.nnz ();
-		  volatile octave_idx_type ii = 0;
-		  retval = SparseMatrix (b_nr, b_nc, x_nz);
-
-		  retval.xcidx(0) = 0;
-		  for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		    {
-		      for (octave_idx_type i = 0; i < b_nr; i++)
-			Bx[i] = b.elem (i, j);
-
-		      F77_XFCN (dpbtrs, DPBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, 1, tmp_data,
-				 ldm, Bx, b_nr, err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      if (err != 0)
-			{
-			  (*current_liboctave_error_handler) 
-			    ("SparseMatrix::solve solve failed");
-			  err = -1;
-			  break;
-			}
-
-		      for (octave_idx_type i = 0; i < b_nr; i++)
-			{
-			  double tmp = Bx[i];
-			  if (tmp != 0.0)
-			    {
-			      if (ii == x_nz)
-				{
-				  // Resize the sparse matrix
-				  octave_idx_type sz = x_nz * 
-				    (b_nc - j) / b_nc;
-				  sz = (sz > 10 ? sz : 10) + x_nz;
-				  retval.change_capacity (sz);
-				  x_nz = sz;
-				}
-			      retval.xdata(ii) = tmp;
-			      retval.xridx(ii++) = i;
-			    }
-			}
-		      retval.xcidx(j+1) = ii;
-		    }
-
-		  retval.maybe_compress ();
-		}
-	    }
-	}
+        {
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              {
+                octave_idx_type ri = ridx (i);
+                if (ri >= j)
+                  m_band(ri - j, j) = data(i);
+              }
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            anorm = m_band.abs().sum().row(0).max();
+
+          char job = 'L';
+          F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                     nr, n_lower, tmp_data, ldm, err
+                                     F77_CHAR_ARG_LEN (1)));
+            
+          if (err != 0) 
+            {
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Banded;
+              rcond = 0.0;
+              err = 0;
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dpbcon, DPBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nr, n_lower, tmp_data, ldm,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  octave_idx_type b_nr = b.rows ();
+                  octave_idx_type b_nc = b.cols ();
+                  OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+
+                  // Take a first guess that the number of non-zero terms
+                  // will be as many as in b
+                  volatile octave_idx_type x_nz = b.nnz ();
+                  volatile octave_idx_type ii = 0;
+                  retval = SparseMatrix (b_nr, b_nc, x_nz);
+
+                  retval.xcidx(0) = 0;
+                  for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                    {
+                      for (octave_idx_type i = 0; i < b_nr; i++)
+                        Bx[i] = b.elem (i, j);
+
+                      F77_XFCN (dpbtrs, DPBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, 1, tmp_data,
+                                 ldm, Bx, b_nr, err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      if (err != 0)
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("SparseMatrix::solve solve failed");
+                          err = -1;
+                          break;
+                        }
+
+                      for (octave_idx_type i = 0; i < b_nr; i++)
+                        {
+                          double tmp = Bx[i];
+                          if (tmp != 0.0)
+                            {
+                              if (ii == x_nz)
+                                {
+                                  // Resize the sparse matrix
+                                  octave_idx_type sz = x_nz * 
+                                    (b_nc - j) / b_nc;
+                                  sz = (sz > 10 ? sz : 10) + x_nz;
+                                  retval.change_capacity (sz);
+                                  x_nz = sz;
+                                }
+                              retval.xdata(ii) = tmp;
+                              retval.xridx(ii++) = i;
+                            }
+                        }
+                      retval.xcidx(j+1) = ii;
+                    }
+
+                  retval.maybe_compress ();
+                }
+            }
+        }
 
       if (typ == MatrixType::Banded)
-	{
-	  // Create the storage for the banded form of the sparse matrix
-	  octave_idx_type n_upper = mattype.nupper ();
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_upper + 2 * n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    {
-	      for (octave_idx_type j = 0; j < nr; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  Array<octave_idx_type> ipvt (nr);
-	  octave_idx_type *pipvt = ipvt.fortran_vec ();
-
-	  F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
-				     ldm, pipvt, err));
-	    
-	  if (err != 0) 
-	    {
-	      err = -2;
-	      rcond = 0.0;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  char job = '1';
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dgbcon, DGBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		   if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  char job = 'N';
-		  volatile octave_idx_type x_nz = b.nnz ();
-		  octave_idx_type b_nc = b.cols ();
-		  retval = SparseMatrix (nr, b_nc, x_nz);
-		  retval.xcidx(0) = 0;
-		  volatile octave_idx_type ii = 0;
-
-		  OCTAVE_LOCAL_BUFFER (double, work, nr);
-
-		  for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		    {
-		      for (octave_idx_type i = 0; i < nr; i++)
-			work[i] = 0.;
-		      for (octave_idx_type i = b.cidx(j); 
-			   i < b.cidx(j+1); i++)
-			work[b.ridx(i)] = b.data(i);
-
-		      F77_XFCN (dgbtrs, DGBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, n_upper, 1, tmp_data,
-				 ldm, pipvt, work, b.rows (), err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      // Count non-zeros in work vector and adjust 
-		      // space in retval if needed
-		      octave_idx_type new_nnz = 0;
-		      for (octave_idx_type i = 0; i < nr; i++)
-			if (work[i] != 0.)
-			  new_nnz++;
-
-		      if (ii + new_nnz > x_nz)
-			{
-			  // Resize the sparse matrix
-			  octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-			  retval.change_capacity (sz);
-			  x_nz = sz;
-			}
-
-		      for (octave_idx_type i = 0; i < nr; i++)
-			if (work[i] != 0.)
-			  {
-			    retval.xridx(ii) = i;
-			    retval.xdata(ii++) = work[i];
-			  }
-		      retval.xcidx(j+1) = ii;
-		    }
-
-		  retval.maybe_compress ();
-		}
-	    }
-	}
+        {
+          // Create the storage for the banded form of the sparse matrix
+          octave_idx_type n_upper = mattype.nupper ();
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_upper + 2 * n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            {
+              for (octave_idx_type j = 0; j < nr; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          Array<octave_idx_type> ipvt (nr);
+          octave_idx_type *pipvt = ipvt.fortran_vec ();
+
+          F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
+                                     ldm, pipvt, err));
+            
+          if (err != 0) 
+            {
+              err = -2;
+              rcond = 0.0;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  char job = '1';
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dgbcon, DGBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                   if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  char job = 'N';
+                  volatile octave_idx_type x_nz = b.nnz ();
+                  octave_idx_type b_nc = b.cols ();
+                  retval = SparseMatrix (nr, b_nc, x_nz);
+                  retval.xcidx(0) = 0;
+                  volatile octave_idx_type ii = 0;
+
+                  OCTAVE_LOCAL_BUFFER (double, work, nr);
+
+                  for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                    {
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        work[i] = 0.;
+                      for (octave_idx_type i = b.cidx(j); 
+                           i < b.cidx(j+1); i++)
+                        work[b.ridx(i)] = b.data(i);
+
+                      F77_XFCN (dgbtrs, DGBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, n_upper, 1, tmp_data,
+                                 ldm, pipvt, work, b.rows (), err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      // Count non-zeros in work vector and adjust 
+                      // space in retval if needed
+                      octave_idx_type new_nnz = 0;
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        if (work[i] != 0.)
+                          new_nnz++;
+
+                      if (ii + new_nnz > x_nz)
+                        {
+                          // Resize the sparse matrix
+                          octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                          retval.change_capacity (sz);
+                          x_nz = sz;
+                        }
+
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        if (work[i] != 0.)
+                          {
+                            retval.xridx(ii) = i;
+                            retval.xdata(ii++) = work[i];
+                          }
+                      retval.xcidx(j+1) = ii;
+                    }
+
+                  retval.maybe_compress ();
+                }
+            }
+        }
       else if (typ != MatrixType::Banded_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -5032,9 +5032,9 @@
 
 ComplexMatrix
 SparseMatrix::bsolve (MatrixType &mattype, const ComplexMatrix& b, 
-		      octave_idx_type& err, double& rcond, 
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond, 
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   ComplexMatrix retval;
 
@@ -5054,276 +5054,276 @@
       mattype.info ();
 
       if (typ == MatrixType::Banded_Hermitian)
-	{
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      {
-		octave_idx_type ri = ridx (i);
-		if (ri >= j)
-		  m_band(ri - j, j) = data(i);
-	      }
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    anorm = m_band.abs().sum().row(0).max();
-
-	  char job = 'L';
-	  F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
-				     nr, n_lower, tmp_data, ldm, err
-				     F77_CHAR_ARG_LEN (1)));
-	    
-	  if (err != 0) 
-	    {
-	      // Matrix is not positive definite!! Fall through to
-	      // unsymmetric banded solver.
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Banded;
-	      rcond = 0.0;
-	      err = 0;
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dpbcon, DPBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nr, n_lower, tmp_data, ldm,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  octave_idx_type b_nr = b.rows ();
-		  octave_idx_type b_nc = b.cols ();
-
-		  OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-		  OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
-
-		  retval.resize (b_nr, b_nc);
-
-		  for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		    {
-		      for (octave_idx_type i = 0; i < b_nr; i++)
-			{
-			  Complex c = b (i,j);
-			  Bx[i] = std::real (c);
-			  Bz[i] = std::imag (c);
-			}
-
-		      F77_XFCN (dpbtrs, DPBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, 1, tmp_data,
-				 ldm, Bx, b_nr, err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      if (err != 0)
-			{
-			  (*current_liboctave_error_handler) 
-			    ("SparseMatrix::solve solve failed");
-			  err = -1;
-			  break;
-			}
-
-		      F77_XFCN (dpbtrs, DPBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, 1, tmp_data,
-				 ldm, Bz, b.rows(), err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      if (err != 0)
-			{
-			  (*current_liboctave_error_handler) 
-			    ("SparseMatrix::solve solve failed");
-			  err = -1;
-			  break;
-			}
-
-		      for (octave_idx_type i = 0; i < b_nr; i++)
-			retval (i, j) = Complex (Bx[i], Bz[i]);
-		    }
-		}
-	    }
-	}
+        {
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              {
+                octave_idx_type ri = ridx (i);
+                if (ri >= j)
+                  m_band(ri - j, j) = data(i);
+              }
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            anorm = m_band.abs().sum().row(0).max();
+
+          char job = 'L';
+          F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                     nr, n_lower, tmp_data, ldm, err
+                                     F77_CHAR_ARG_LEN (1)));
+            
+          if (err != 0) 
+            {
+              // Matrix is not positive definite!! Fall through to
+              // unsymmetric banded solver.
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Banded;
+              rcond = 0.0;
+              err = 0;
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dpbcon, DPBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nr, n_lower, tmp_data, ldm,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  octave_idx_type b_nr = b.rows ();
+                  octave_idx_type b_nc = b.cols ();
+
+                  OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+                  OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
+
+                  retval.resize (b_nr, b_nc);
+
+                  for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                    {
+                      for (octave_idx_type i = 0; i < b_nr; i++)
+                        {
+                          Complex c = b (i,j);
+                          Bx[i] = std::real (c);
+                          Bz[i] = std::imag (c);
+                        }
+
+                      F77_XFCN (dpbtrs, DPBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, 1, tmp_data,
+                                 ldm, Bx, b_nr, err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      if (err != 0)
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("SparseMatrix::solve solve failed");
+                          err = -1;
+                          break;
+                        }
+
+                      F77_XFCN (dpbtrs, DPBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, 1, tmp_data,
+                                 ldm, Bz, b.rows(), err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      if (err != 0)
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("SparseMatrix::solve solve failed");
+                          err = -1;
+                          break;
+                        }
+
+                      for (octave_idx_type i = 0; i < b_nr; i++)
+                        retval (i, j) = Complex (Bx[i], Bz[i]);
+                    }
+                }
+            }
+        }
 
       if (typ == MatrixType::Banded)
-	{
-	  // Create the storage for the banded form of the sparse matrix
-	  octave_idx_type n_upper = mattype.nupper ();
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_upper + 2 * n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    {
-	      for (octave_idx_type j = 0; j < nr; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  Array<octave_idx_type> ipvt (nr);
-	  octave_idx_type *pipvt = ipvt.fortran_vec ();
-
-	  F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
-				     ldm, pipvt, err));
-	    
-	  if (err != 0) 
-	    {
-	      err = -2;
-	      rcond = 0.0;
-
-	      if (sing_handler)
-		{
-		sing_handler (rcond);
-		mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  char job = '1';
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dpbcon, DPBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nr, n_lower, tmp_data, ldm,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			sing_handler (rcond);
-			mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  char job = 'N';
-		  octave_idx_type b_nc = b.cols ();
-		  retval.resize (nr,b_nc);
-
-		  OCTAVE_LOCAL_BUFFER (double, Bz, nr);
-		  OCTAVE_LOCAL_BUFFER (double, Bx, nr);
-
-		  for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		    {
-		      for (octave_idx_type i = 0; i < nr; i++)
-			{
-			  Complex c = b (i, j);
-			  Bx[i] = std::real (c);
-			  Bz[i] = std::imag  (c);
-			}
-
-		      F77_XFCN (dgbtrs, DGBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, n_upper, 1, tmp_data,
-				 ldm, pipvt, Bx, b.rows (), err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      F77_XFCN (dgbtrs, DGBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, n_upper, 1, tmp_data,
-				 ldm, pipvt, Bz, b.rows (), err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      for (octave_idx_type i = 0; i < nr; i++)
-			retval (i, j) = Complex (Bx[i], Bz[i]);
-		    }
-		}
-	    }
-	}
+        {
+          // Create the storage for the banded form of the sparse matrix
+          octave_idx_type n_upper = mattype.nupper ();
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_upper + 2 * n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            {
+              for (octave_idx_type j = 0; j < nr; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          Array<octave_idx_type> ipvt (nr);
+          octave_idx_type *pipvt = ipvt.fortran_vec ();
+
+          F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
+                                     ldm, pipvt, err));
+            
+          if (err != 0) 
+            {
+              err = -2;
+              rcond = 0.0;
+
+              if (sing_handler)
+                {
+                sing_handler (rcond);
+                mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  char job = '1';
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dpbcon, DPBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nr, n_lower, tmp_data, ldm,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                        sing_handler (rcond);
+                        mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  char job = 'N';
+                  octave_idx_type b_nc = b.cols ();
+                  retval.resize (nr,b_nc);
+
+                  OCTAVE_LOCAL_BUFFER (double, Bz, nr);
+                  OCTAVE_LOCAL_BUFFER (double, Bx, nr);
+
+                  for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                    {
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        {
+                          Complex c = b (i, j);
+                          Bx[i] = std::real (c);
+                          Bz[i] = std::imag  (c);
+                        }
+
+                      F77_XFCN (dgbtrs, DGBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, n_upper, 1, tmp_data,
+                                 ldm, pipvt, Bx, b.rows (), err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      F77_XFCN (dgbtrs, DGBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, n_upper, 1, tmp_data,
+                                 ldm, pipvt, Bz, b.rows (), err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        retval (i, j) = Complex (Bx[i], Bz[i]);
+                    }
+                }
+            }
+        }
       else if (typ != MatrixType::Banded_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
 
   return retval;
@@ -5331,9 +5331,9 @@
 
 SparseComplexMatrix
 SparseMatrix::bsolve (MatrixType &mattype, const SparseComplexMatrix& b,
-		      octave_idx_type& err, double& rcond, 
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond, 
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   SparseComplexMatrix retval;
 
@@ -5353,339 +5353,339 @@
       mattype.info ();
 
       if (typ == MatrixType::Banded_Hermitian)
-	{
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      {
-		octave_idx_type ri = ridx (i);
-		if (ri >= j)
-		  m_band(ri - j, j) = data(i);
-	      }
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    anorm = m_band.abs().sum().row(0).max();
-
-	  char job = 'L';
-	  F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
-				     nr, n_lower, tmp_data, ldm, err
-				     F77_CHAR_ARG_LEN (1)));
-	    
-	  if (err != 0) 
-	    {
-	      // Matrix is not positive definite!! Fall through to
-	      // unsymmetric banded solver.
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Banded;
-
-	      rcond = 0.0;
-	      err = 0;
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dpbcon, DPBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nr, n_lower, tmp_data, ldm,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		  if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  octave_idx_type b_nr = b.rows ();
-		  octave_idx_type b_nc = b.cols ();
-		  OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-		  OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
-
-		  // Take a first guess that the number of non-zero terms
-		  // will be as many as in b
-		  volatile octave_idx_type x_nz = b.nnz ();
-		  volatile octave_idx_type ii = 0;
-		  retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
-
-		  retval.xcidx(0) = 0;
-		  for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		    {
-
-		      for (octave_idx_type i = 0; i < b_nr; i++)
-			{
-			  Complex c = b (i,j);
-			  Bx[i] = std::real (c);
-			  Bz[i] = std::imag (c);
-			}
-
-		      F77_XFCN (dpbtrs, DPBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, 1, tmp_data,
-				 ldm, Bx, b_nr, err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      if (err != 0)
-			{
-			  (*current_liboctave_error_handler) 
-			    ("SparseMatrix::solve solve failed");
-			  err = -1;
-			  break;
-			}
-
-		      F77_XFCN (dpbtrs, DPBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, 1, tmp_data,
-				 ldm, Bz, b_nr, err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      if (err != 0)
-			{
-			  (*current_liboctave_error_handler)
-			    ("SparseMatrix::solve solve failed");
-
-			  err = -1;
-			  break;
-			}
-
-		      // Count non-zeros in work vector and adjust 
-		      // space in retval if needed
-		      octave_idx_type new_nnz = 0;
-		      for (octave_idx_type i = 0; i < nr; i++)
-			if (Bx[i] != 0. || Bz[i] != 0.)
-			  new_nnz++;
-
-		      if (ii + new_nnz > x_nz)
-			{
-			  // Resize the sparse matrix
-			  octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-			  retval.change_capacity (sz);
-			  x_nz = sz;
-			}
-
-		      for (octave_idx_type i = 0; i < nr; i++)
-			if (Bx[i] != 0. || Bz[i] != 0.)
-			  {
-			    retval.xridx(ii) = i;
-			    retval.xdata(ii++) = 
-			      Complex (Bx[i], Bz[i]);
-			  }
-
-		      retval.xcidx(j+1) = ii;
-		    }
-
-		  retval.maybe_compress ();
-		}
-	    }
-	}
+        {
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              {
+                octave_idx_type ri = ridx (i);
+                if (ri >= j)
+                  m_band(ri - j, j) = data(i);
+              }
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            anorm = m_band.abs().sum().row(0).max();
+
+          char job = 'L';
+          F77_XFCN (dpbtrf, DPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
+                                     nr, n_lower, tmp_data, ldm, err
+                                     F77_CHAR_ARG_LEN (1)));
+            
+          if (err != 0) 
+            {
+              // Matrix is not positive definite!! Fall through to
+              // unsymmetric banded solver.
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Banded;
+
+              rcond = 0.0;
+              err = 0;
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dpbcon, DPBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nr, n_lower, tmp_data, ldm,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                  if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  octave_idx_type b_nr = b.rows ();
+                  octave_idx_type b_nc = b.cols ();
+                  OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+                  OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
+
+                  // Take a first guess that the number of non-zero terms
+                  // will be as many as in b
+                  volatile octave_idx_type x_nz = b.nnz ();
+                  volatile octave_idx_type ii = 0;
+                  retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
+
+                  retval.xcidx(0) = 0;
+                  for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                    {
+
+                      for (octave_idx_type i = 0; i < b_nr; i++)
+                        {
+                          Complex c = b (i,j);
+                          Bx[i] = std::real (c);
+                          Bz[i] = std::imag (c);
+                        }
+
+                      F77_XFCN (dpbtrs, DPBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, 1, tmp_data,
+                                 ldm, Bx, b_nr, err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      if (err != 0)
+                        {
+                          (*current_liboctave_error_handler) 
+                            ("SparseMatrix::solve solve failed");
+                          err = -1;
+                          break;
+                        }
+
+                      F77_XFCN (dpbtrs, DPBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, 1, tmp_data,
+                                 ldm, Bz, b_nr, err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      if (err != 0)
+                        {
+                          (*current_liboctave_error_handler)
+                            ("SparseMatrix::solve solve failed");
+
+                          err = -1;
+                          break;
+                        }
+
+                      // Count non-zeros in work vector and adjust 
+                      // space in retval if needed
+                      octave_idx_type new_nnz = 0;
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        if (Bx[i] != 0. || Bz[i] != 0.)
+                          new_nnz++;
+
+                      if (ii + new_nnz > x_nz)
+                        {
+                          // Resize the sparse matrix
+                          octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                          retval.change_capacity (sz);
+                          x_nz = sz;
+                        }
+
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        if (Bx[i] != 0. || Bz[i] != 0.)
+                          {
+                            retval.xridx(ii) = i;
+                            retval.xdata(ii++) = 
+                              Complex (Bx[i], Bz[i]);
+                          }
+
+                      retval.xcidx(j+1) = ii;
+                    }
+
+                  retval.maybe_compress ();
+                }
+            }
+        }
 
       if (typ == MatrixType::Banded)
-	{
-	  // Create the storage for the banded form of the sparse matrix
-	  octave_idx_type n_upper = mattype.nupper ();
-	  octave_idx_type n_lower = mattype.nlower ();
-	  octave_idx_type ldm = n_upper + 2 * n_lower + 1;
-
-	  Matrix m_band (ldm, nc);
-	  double *tmp_data = m_band.fortran_vec ();
-	      
-	  if (! mattype.is_dense ()) 
-	    {
-	      octave_idx_type ii = 0;
-
-	      for (octave_idx_type j = 0; j < ldm; j++)
-		for (octave_idx_type i = 0; i < nc; i++)
-		  tmp_data[ii++] = 0.;
-	    }
-
-	  for (octave_idx_type j = 0; j < nc; j++)
-	    for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-	      m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
-
-	  // Calculate the norm of the matrix, for later use.
-	  double anorm;
-	  if (calc_cond)
-	    {
-	      for (octave_idx_type j = 0; j < nr; j++)
-		{
-		  double atmp = 0.;
-		  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
-		    atmp += fabs(data(i));
-		  if (atmp > anorm)
-		    anorm = atmp;
-		}
-	    }
-
-	  Array<octave_idx_type> ipvt (nr);
-	  octave_idx_type *pipvt = ipvt.fortran_vec ();
-
-	  F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
-				     ldm, pipvt, err));
-	    
-	  if (err != 0) 
-	    {
-	      err = -2;
-	      rcond = 0.0;
-
-	      if (sing_handler)
-		{
-		  sing_handler (rcond);
-		  mattype.mark_as_rectangular ();
-		}
-	      else
-		(*current_liboctave_error_handler)
-		  ("matrix singular to machine precision");
-
-	    } 
-	  else 
-	    {
-	      if (calc_cond)
-		{
-		  char job = '1';
-		  Array<double> z (3 * nr);
-		  double *pz = z.fortran_vec ();
-		  Array<octave_idx_type> iz (nr);
-		  octave_idx_type *piz = iz.fortran_vec ();
-
-		  F77_XFCN (dgbcon, DGBCON, 
-		    (F77_CONST_CHAR_ARG2 (&job, 1),
-		     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
-		     anorm, rcond, pz, piz, err
-		     F77_CHAR_ARG_LEN (1)));
-
-		   if (err != 0) 
-		    err = -2;
-
-		  volatile double rcond_plus_one = rcond + 1.0;
-
-		  if (rcond_plus_one == 1.0 || xisnan (rcond))
-		    {
-		      err = -2;
-
-		      if (sing_handler)
-			{
-			  sing_handler (rcond);
-			  mattype.mark_as_rectangular ();
-			}
-		      else
-			(*current_liboctave_error_handler)
-			  ("matrix singular to machine precision, rcond = %g",
-			   rcond);
-		    }
-		}
-	      else
-		rcond = 1.;
-
-	      if (err == 0)
-		{
-		  char job = 'N';
-		  volatile octave_idx_type x_nz = b.nnz ();
-		  octave_idx_type b_nc = b.cols ();
-		  retval = SparseComplexMatrix (nr, b_nc, x_nz);
-		  retval.xcidx(0) = 0;
-		  volatile octave_idx_type ii = 0;
-
-		  OCTAVE_LOCAL_BUFFER (double, Bx, nr);
-		  OCTAVE_LOCAL_BUFFER (double, Bz, nr);
-
-		  for (volatile octave_idx_type j = 0; j < b_nc; j++)
-		    {
-		      for (octave_idx_type i = 0; i < nr; i++)
-			{
-			  Bx[i] = 0.;
-			  Bz[i] = 0.;
-			}
-		      for (octave_idx_type i = b.cidx(j); 
-			   i < b.cidx(j+1); i++)
-			{
-			  Complex c = b.data(i);
-			  Bx[b.ridx(i)] = std::real (c);
-			  Bz[b.ridx(i)] = std::imag (c);
-			}
-
-		      F77_XFCN (dgbtrs, DGBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, n_upper, 1, tmp_data,
-				 ldm, pipvt, Bx, b.rows (), err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      F77_XFCN (dgbtrs, DGBTRS, 
-				(F77_CONST_CHAR_ARG2 (&job, 1),
-				 nr, n_lower, n_upper, 1, tmp_data,
-				 ldm, pipvt, Bz, b.rows (), err
-				 F77_CHAR_ARG_LEN (1)));
-
-		      // Count non-zeros in work vector and adjust 
-		      // space in retval if needed
-		      octave_idx_type new_nnz = 0;
-		      for (octave_idx_type i = 0; i < nr; i++)
-			if (Bx[i] != 0. || Bz[i] != 0.)
-			  new_nnz++;
-
-		      if (ii + new_nnz > x_nz)
-			{
-			  // Resize the sparse matrix
-			  octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
-			  retval.change_capacity (sz);
-			  x_nz = sz;
-			}
-
-		      for (octave_idx_type i = 0; i < nr; i++)
-			if (Bx[i] != 0. || Bz[i] != 0.)
-			  {
-			    retval.xridx(ii) = i;
-			    retval.xdata(ii++) = 
-			      Complex (Bx[i], Bz[i]);
-			  }
-		      retval.xcidx(j+1) = ii;
-		    }
-
-		  retval.maybe_compress ();
-		}
-	    }
-	}
+        {
+          // Create the storage for the banded form of the sparse matrix
+          octave_idx_type n_upper = mattype.nupper ();
+          octave_idx_type n_lower = mattype.nlower ();
+          octave_idx_type ldm = n_upper + 2 * n_lower + 1;
+
+          Matrix m_band (ldm, nc);
+          double *tmp_data = m_band.fortran_vec ();
+              
+          if (! mattype.is_dense ()) 
+            {
+              octave_idx_type ii = 0;
+
+              for (octave_idx_type j = 0; j < ldm; j++)
+                for (octave_idx_type i = 0; i < nc; i++)
+                  tmp_data[ii++] = 0.;
+            }
+
+          for (octave_idx_type j = 0; j < nc; j++)
+            for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+              m_band(ridx(i) - j + n_lower + n_upper, j) = data(i);
+
+          // Calculate the norm of the matrix, for later use.
+          double anorm;
+          if (calc_cond)
+            {
+              for (octave_idx_type j = 0; j < nr; j++)
+                {
+                  double atmp = 0.;
+                  for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+                    atmp += fabs(data(i));
+                  if (atmp > anorm)
+                    anorm = atmp;
+                }
+            }
+
+          Array<octave_idx_type> ipvt (nr);
+          octave_idx_type *pipvt = ipvt.fortran_vec ();
+
+          F77_XFCN (dgbtrf, DGBTRF, (nr, nr, n_lower, n_upper, tmp_data, 
+                                     ldm, pipvt, err));
+            
+          if (err != 0) 
+            {
+              err = -2;
+              rcond = 0.0;
+
+              if (sing_handler)
+                {
+                  sing_handler (rcond);
+                  mattype.mark_as_rectangular ();
+                }
+              else
+                (*current_liboctave_error_handler)
+                  ("matrix singular to machine precision");
+
+            } 
+          else 
+            {
+              if (calc_cond)
+                {
+                  char job = '1';
+                  Array<double> z (3 * nr);
+                  double *pz = z.fortran_vec ();
+                  Array<octave_idx_type> iz (nr);
+                  octave_idx_type *piz = iz.fortran_vec ();
+
+                  F77_XFCN (dgbcon, DGBCON, 
+                    (F77_CONST_CHAR_ARG2 (&job, 1),
+                     nc, n_lower, n_upper, tmp_data, ldm, pipvt,
+                     anorm, rcond, pz, piz, err
+                     F77_CHAR_ARG_LEN (1)));
+
+                   if (err != 0) 
+                    err = -2;
+
+                  volatile double rcond_plus_one = rcond + 1.0;
+
+                  if (rcond_plus_one == 1.0 || xisnan (rcond))
+                    {
+                      err = -2;
+
+                      if (sing_handler)
+                        {
+                          sing_handler (rcond);
+                          mattype.mark_as_rectangular ();
+                        }
+                      else
+                        (*current_liboctave_error_handler)
+                          ("matrix singular to machine precision, rcond = %g",
+                           rcond);
+                    }
+                }
+              else
+                rcond = 1.;
+
+              if (err == 0)
+                {
+                  char job = 'N';
+                  volatile octave_idx_type x_nz = b.nnz ();
+                  octave_idx_type b_nc = b.cols ();
+                  retval = SparseComplexMatrix (nr, b_nc, x_nz);
+                  retval.xcidx(0) = 0;
+                  volatile octave_idx_type ii = 0;
+
+                  OCTAVE_LOCAL_BUFFER (double, Bx, nr);
+                  OCTAVE_LOCAL_BUFFER (double, Bz, nr);
+
+                  for (volatile octave_idx_type j = 0; j < b_nc; j++)
+                    {
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        {
+                          Bx[i] = 0.;
+                          Bz[i] = 0.;
+                        }
+                      for (octave_idx_type i = b.cidx(j); 
+                           i < b.cidx(j+1); i++)
+                        {
+                          Complex c = b.data(i);
+                          Bx[b.ridx(i)] = std::real (c);
+                          Bz[b.ridx(i)] = std::imag (c);
+                        }
+
+                      F77_XFCN (dgbtrs, DGBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, n_upper, 1, tmp_data,
+                                 ldm, pipvt, Bx, b.rows (), err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      F77_XFCN (dgbtrs, DGBTRS, 
+                                (F77_CONST_CHAR_ARG2 (&job, 1),
+                                 nr, n_lower, n_upper, 1, tmp_data,
+                                 ldm, pipvt, Bz, b.rows (), err
+                                 F77_CHAR_ARG_LEN (1)));
+
+                      // Count non-zeros in work vector and adjust 
+                      // space in retval if needed
+                      octave_idx_type new_nnz = 0;
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        if (Bx[i] != 0. || Bz[i] != 0.)
+                          new_nnz++;
+
+                      if (ii + new_nnz > x_nz)
+                        {
+                          // Resize the sparse matrix
+                          octave_idx_type sz = new_nnz * (b_nc - j) + x_nz;
+                          retval.change_capacity (sz);
+                          x_nz = sz;
+                        }
+
+                      for (octave_idx_type i = 0; i < nr; i++)
+                        if (Bx[i] != 0. || Bz[i] != 0.)
+                          {
+                            retval.xridx(ii) = i;
+                            retval.xdata(ii++) = 
+                              Complex (Bx[i], Bz[i]);
+                          }
+                      retval.xcidx(j+1) = ii;
+                    }
+
+                  retval.maybe_compress ();
+                }
+            }
+        }
       else if (typ != MatrixType::Banded_Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
   
   return retval;
@@ -5693,8 +5693,8 @@
 
 void *
 SparseMatrix::factorize (octave_idx_type& err, double &rcond, Matrix &Control,
-			 Matrix &Info, solve_singularity_handler sing_handler,
-			 bool calc_cond) const
+                         Matrix &Info, solve_singularity_handler sing_handler,
+                         bool calc_cond) const
 {
   // The return values
   void *Numeric = 0;
@@ -5735,12 +5735,12 @@
   Info = Matrix (1, UMFPACK_INFO);
   double *info = Info.fortran_vec ();
   int status = UMFPACK_DNAME (qsymbolic) (nr, nc, Ap, Ai, Ax, 0,
-				     &Symbolic, control, info);
+                                     &Symbolic, control, info);
 
   if (status < 0)
     {
       (*current_liboctave_error_handler) 
-	("SparseMatrix::solve symbolic factorization failed");
+        ("SparseMatrix::solve symbolic factorization failed");
       err = -1;
 
       UMFPACK_DNAME (report_status) (control, status);
@@ -5753,44 +5753,44 @@
       UMFPACK_DNAME (report_symbolic) (Symbolic, control);
 
       status = UMFPACK_DNAME (numeric) (Ap, Ai, Ax, Symbolic,
-				   &Numeric, control, info) ;
+                                   &Numeric, control, info) ;
       UMFPACK_DNAME (free_symbolic) (&Symbolic) ;
 
       if (calc_cond)
-	rcond = Info (UMFPACK_RCOND);
+        rcond = Info (UMFPACK_RCOND);
       else
-	rcond = 1.;
+        rcond = 1.;
       volatile double rcond_plus_one = rcond + 1.0;
 
       if (status == UMFPACK_WARNING_singular_matrix || 
-	  rcond_plus_one == 1.0 || xisnan (rcond))
-	{
-	  UMFPACK_DNAME (report_numeric) (Numeric, control);
-
-	  err = -2;
-
-	  if (sing_handler)
-	    sing_handler (rcond);
-	  else
-	    (*current_liboctave_error_handler)
-	      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-	       rcond);
-
-	}
+          rcond_plus_one == 1.0 || xisnan (rcond))
+        {
+          UMFPACK_DNAME (report_numeric) (Numeric, control);
+
+          err = -2;
+
+          if (sing_handler)
+            sing_handler (rcond);
+          else
+            (*current_liboctave_error_handler)
+              ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+               rcond);
+
+        }
       else if (status < 0)
-	  {
-	    (*current_liboctave_error_handler) 
-	      ("SparseMatrix::solve numeric factorization failed");
-
-	    UMFPACK_DNAME (report_status) (control, status);
-	    UMFPACK_DNAME (report_info) (control, info);
-	      
-	    err = -1;
-	  }
-	else
-	  {
-	    UMFPACK_DNAME (report_numeric) (Numeric, control);
-	  }
+          {
+            (*current_liboctave_error_handler) 
+              ("SparseMatrix::solve numeric factorization failed");
+
+            UMFPACK_DNAME (report_status) (control, status);
+            UMFPACK_DNAME (report_info) (control, info);
+              
+            err = -1;
+          }
+        else
+          {
+            UMFPACK_DNAME (report_numeric) (Numeric, control);
+          }
     }
 
   if (err != 0)
@@ -5805,9 +5805,9 @@
 
 Matrix
 SparseMatrix::fsolve (MatrixType &mattype, const Matrix& b,
-		      octave_idx_type& err, double& rcond, 
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond, 
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   Matrix retval;
 
@@ -5827,193 +5827,193 @@
       mattype.info ();
 
       if (typ == MatrixType::Hermitian)
-	{
+        {
 #ifdef HAVE_CHOLMOD
-	  cholmod_common Common;
-	  cholmod_common *cm = &Common;
-
-	  // Setup initial parameters
-	  CHOLMOD_NAME(start) (cm);
-	  cm->prefer_zomplex = false;
-
-	  double spu = octave_sparse_params::get_key ("spumoni");
-	  if (spu == 0.)
-	    {
-	      cm->print = -1;
-	      cm->print_function = 0;
-	    }
-	  else
-	    {
-	      cm->print = static_cast<int> (spu) + 2;
-	      cm->print_function =&SparseCholPrint;
-	    }
-
-	  cm->error_handler = &SparseCholError;
-	  cm->complex_divide = CHOLMOD_NAME(divcomplex);
-	  cm->hypotenuse = CHOLMOD_NAME(hypot);
-
-	  cm->final_ll = true;
-
-	  cholmod_sparse Astore;
-	  cholmod_sparse *A = &Astore;
-	  double dummy;
-	  A->nrow = nr;
-	  A->ncol = nc;
-
-	  A->p = cidx();
-	  A->i = ridx();
-	  A->nzmax = nnz();
-	  A->packed = true;
-	  A->sorted = true;
-	  A->nz = 0;
+          cholmod_common Common;
+          cholmod_common *cm = &Common;
+
+          // Setup initial parameters
+          CHOLMOD_NAME(start) (cm);
+          cm->prefer_zomplex = false;
+
+          double spu = octave_sparse_params::get_key ("spumoni");
+          if (spu == 0.)
+            {
+              cm->print = -1;
+              cm->print_function = 0;
+            }
+          else
+            {
+              cm->print = static_cast<int> (spu) + 2;
+              cm->print_function =&SparseCholPrint;
+            }
+
+          cm->error_handler = &SparseCholError;
+          cm->complex_divide = CHOLMOD_NAME(divcomplex);
+          cm->hypotenuse = CHOLMOD_NAME(hypot);
+
+          cm->final_ll = true;
+
+          cholmod_sparse Astore;
+          cholmod_sparse *A = &Astore;
+          double dummy;
+          A->nrow = nr;
+          A->ncol = nc;
+
+          A->p = cidx();
+          A->i = ridx();
+          A->nzmax = nnz();
+          A->packed = true;
+          A->sorted = true;
+          A->nz = 0;
 #ifdef IDX_TYPE_LONG
-	  A->itype = CHOLMOD_LONG;
+          A->itype = CHOLMOD_LONG;
 #else
-	  A->itype = CHOLMOD_INT;
+          A->itype = CHOLMOD_INT;
 #endif
-	  A->dtype = CHOLMOD_DOUBLE;
-	  A->stype = 1;
-	  A->xtype = CHOLMOD_REAL;
-
-	  if (nr < 1)
-	    A->x = &dummy;
-	  else
-	    A->x = data();
-
-	  cholmod_dense Bstore;
-	  cholmod_dense *B = &Bstore;
-	  B->nrow = b.rows();
-	  B->ncol = b.cols();
-	  B->d = B->nrow;
-	  B->nzmax = B->nrow * B->ncol;
-	  B->dtype = CHOLMOD_DOUBLE;
-	  B->xtype = CHOLMOD_REAL;
-	  if (nc < 1 || b.cols() < 1)
-	    B->x = &dummy;
-	  else
-	    // We won't alter it, honest :-)
-	    B->x = const_cast<double *>(b.fortran_vec());
-
-	  cholmod_factor *L;
-	  BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	  L = CHOLMOD_NAME(analyze) (A, cm);
-	  CHOLMOD_NAME(factorize) (A, L, cm);
-	  if (calc_cond)
-	    rcond = CHOLMOD_NAME(rcond)(L, cm);
-	  else
-	    rcond = 1.0;
-
-	  END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	  if (rcond == 0.0)
-	    {
-	      // Either its indefinite or singular. Try UMFPACK
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Full;
-	    }
-	  else
-	    {
-	      volatile double rcond_plus_one = rcond + 1.0;
-
-	      if (rcond_plus_one == 1.0 || xisnan (rcond))
-		{
-		  err = -2;
-
-		  if (sing_handler)
-		    {
-		      sing_handler (rcond);
-		      mattype.mark_as_rectangular ();
-		    }
-		  else
-		    (*current_liboctave_error_handler)
-		      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		       rcond);
-	      
-		  return retval;
-		}
-
-	      cholmod_dense *X;
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      X = CHOLMOD_NAME(solve) (CHOLMOD_A, L, B, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	      retval.resize (b.rows (), b.cols());
-	      for (octave_idx_type j = 0; j < b.cols(); j++)
-		{
-		  octave_idx_type jr = j * b.rows();
-		  for (octave_idx_type i = 0; i < b.rows(); i++)
-		    retval.xelem(i,j) = static_cast<double *>(X->x)[jr + i];
-		}
-
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      CHOLMOD_NAME(free_dense) (&X, cm);
-	      CHOLMOD_NAME(free_factor) (&L, cm);
-	      CHOLMOD_NAME(finish) (cm);
-	      static char tmp[] = " ";
-	      CHOLMOD_NAME(print_common) (tmp, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	    }
+          A->dtype = CHOLMOD_DOUBLE;
+          A->stype = 1;
+          A->xtype = CHOLMOD_REAL;
+
+          if (nr < 1)
+            A->x = &dummy;
+          else
+            A->x = data();
+
+          cholmod_dense Bstore;
+          cholmod_dense *B = &Bstore;
+          B->nrow = b.rows();
+          B->ncol = b.cols();
+          B->d = B->nrow;
+          B->nzmax = B->nrow * B->ncol;
+          B->dtype = CHOLMOD_DOUBLE;
+          B->xtype = CHOLMOD_REAL;
+          if (nc < 1 || b.cols() < 1)
+            B->x = &dummy;
+          else
+            // We won't alter it, honest :-)
+            B->x = const_cast<double *>(b.fortran_vec());
+
+          cholmod_factor *L;
+          BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+          L = CHOLMOD_NAME(analyze) (A, cm);
+          CHOLMOD_NAME(factorize) (A, L, cm);
+          if (calc_cond)
+            rcond = CHOLMOD_NAME(rcond)(L, cm);
+          else
+            rcond = 1.0;
+
+          END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+          if (rcond == 0.0)
+            {
+              // Either its indefinite or singular. Try UMFPACK
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Full;
+            }
+          else
+            {
+              volatile double rcond_plus_one = rcond + 1.0;
+
+              if (rcond_plus_one == 1.0 || xisnan (rcond))
+                {
+                  err = -2;
+
+                  if (sing_handler)
+                    {
+                      sing_handler (rcond);
+                      mattype.mark_as_rectangular ();
+                    }
+                  else
+                    (*current_liboctave_error_handler)
+                      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                       rcond);
+              
+                  return retval;
+                }
+
+              cholmod_dense *X;
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              X = CHOLMOD_NAME(solve) (CHOLMOD_A, L, B, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+              retval.resize (b.rows (), b.cols());
+              for (octave_idx_type j = 0; j < b.cols(); j++)
+                {
+                  octave_idx_type jr = j * b.rows();
+                  for (octave_idx_type i = 0; i < b.rows(); i++)
+                    retval.xelem(i,j) = static_cast<double *>(X->x)[jr + i];
+                }
+
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              CHOLMOD_NAME(free_dense) (&X, cm);
+              CHOLMOD_NAME(free_factor) (&L, cm);
+              CHOLMOD_NAME(finish) (cm);
+              static char tmp[] = " ";
+              CHOLMOD_NAME(print_common) (tmp, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+            }
 #else
-	  (*current_liboctave_warning_handler)
-	    ("CHOLMOD not installed");
-
-	  mattype.mark_as_unsymmetric ();
-	  typ = MatrixType::Full;
+          (*current_liboctave_warning_handler)
+            ("CHOLMOD not installed");
+
+          mattype.mark_as_unsymmetric ();
+          typ = MatrixType::Full;
 #endif
-	}
+        }
 
       if (typ == MatrixType::Full)
-	{
+        {
 #ifdef HAVE_UMFPACK
-	  Matrix Control, Info;
-	  void *Numeric = 
-	    factorize (err, rcond, Control, Info, sing_handler, calc_cond);
-
-	  if (err == 0)
-	    {
-	      const double *Bx = b.fortran_vec ();
-	      retval.resize (b.rows (), b.cols());
-	      double *result = retval.fortran_vec ();
-	      octave_idx_type b_nr = b.rows ();
-	      octave_idx_type b_nc = b.cols ();
-	      int status = 0;
-	      double *control = Control.fortran_vec ();
-	      double *info = Info.fortran_vec ();
-	      const octave_idx_type *Ap = cidx ();
-	      const octave_idx_type *Ai = ridx ();
-	      const double *Ax = data ();
-
-	      for (octave_idx_type j = 0, iidx = 0; j < b_nc; j++, iidx += b_nr)
-		{
-		  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap, 
-					     Ai, Ax, &result[iidx], &Bx[iidx],
-					     Numeric, control, info);
-		  if (status < 0)
-		    {
-		      (*current_liboctave_error_handler) 
-			("SparseMatrix::solve solve failed");
-
-		      UMFPACK_DNAME (report_status) (control, status);
-		      
-		      err = -1;
-		  
-		      break;
-		    }
-		}
-
-	      UMFPACK_DNAME (report_info) (control, info);
-		
-	      UMFPACK_DNAME (free_numeric) (&Numeric);
-	    }
-	  else
-	    mattype.mark_as_rectangular ();
+          Matrix Control, Info;
+          void *Numeric = 
+            factorize (err, rcond, Control, Info, sing_handler, calc_cond);
+
+          if (err == 0)
+            {
+              const double *Bx = b.fortran_vec ();
+              retval.resize (b.rows (), b.cols());
+              double *result = retval.fortran_vec ();
+              octave_idx_type b_nr = b.rows ();
+              octave_idx_type b_nc = b.cols ();
+              int status = 0;
+              double *control = Control.fortran_vec ();
+              double *info = Info.fortran_vec ();
+              const octave_idx_type *Ap = cidx ();
+              const octave_idx_type *Ai = ridx ();
+              const double *Ax = data ();
+
+              for (octave_idx_type j = 0, iidx = 0; j < b_nc; j++, iidx += b_nr)
+                {
+                  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap, 
+                                             Ai, Ax, &result[iidx], &Bx[iidx],
+                                             Numeric, control, info);
+                  if (status < 0)
+                    {
+                      (*current_liboctave_error_handler) 
+                        ("SparseMatrix::solve solve failed");
+
+                      UMFPACK_DNAME (report_status) (control, status);
+                      
+                      err = -1;
+                  
+                      break;
+                    }
+                }
+
+              UMFPACK_DNAME (report_info) (control, info);
+                
+              UMFPACK_DNAME (free_numeric) (&Numeric);
+            }
+          else
+            mattype.mark_as_rectangular ();
 
 #else
-	  (*current_liboctave_error_handler) ("UMFPACK not installed");
+          (*current_liboctave_error_handler) ("UMFPACK not installed");
 #endif
-	}
+        }
       else if (typ != MatrixType::Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
   
   return retval;
@@ -6021,9 +6021,9 @@
 
 SparseMatrix
 SparseMatrix::fsolve (MatrixType &mattype, const SparseMatrix& b,
-		      octave_idx_type& err, double& rcond,
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond,
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   SparseMatrix retval;
 
@@ -6043,239 +6043,239 @@
       mattype.info ();
 
       if (typ == MatrixType::Hermitian)
-	{
+        {
 #ifdef HAVE_CHOLMOD
-	  cholmod_common Common;
-	  cholmod_common *cm = &Common;
-
-	  // Setup initial parameters
-	  CHOLMOD_NAME(start) (cm);
-	  cm->prefer_zomplex = false;
-
-	  double spu = octave_sparse_params::get_key ("spumoni");
-	  if (spu == 0.)
-	    {
-	      cm->print = -1;
-	      cm->print_function = 0;
-	    }
-	  else
-	    {
-	      cm->print = static_cast<int> (spu) + 2;
-	      cm->print_function =&SparseCholPrint;
-	    }
-
-	  cm->error_handler = &SparseCholError;
-	  cm->complex_divide = CHOLMOD_NAME(divcomplex);
-	  cm->hypotenuse = CHOLMOD_NAME(hypot);
-
-	  cm->final_ll = true;
-
-	  cholmod_sparse Astore;
-	  cholmod_sparse *A = &Astore;
-	  double dummy;
-	  A->nrow = nr;
-	  A->ncol = nc;
-
-	  A->p = cidx();
-	  A->i = ridx();
-	  A->nzmax = nnz();
-	  A->packed = true;
-	  A->sorted = true;
-	  A->nz = 0;
+          cholmod_common Common;
+          cholmod_common *cm = &Common;
+
+          // Setup initial parameters
+          CHOLMOD_NAME(start) (cm);
+          cm->prefer_zomplex = false;
+
+          double spu = octave_sparse_params::get_key ("spumoni");
+          if (spu == 0.)
+            {
+              cm->print = -1;
+              cm->print_function = 0;
+            }
+          else
+            {
+              cm->print = static_cast<int> (spu) + 2;
+              cm->print_function =&SparseCholPrint;
+            }
+
+          cm->error_handler = &SparseCholError;
+          cm->complex_divide = CHOLMOD_NAME(divcomplex);
+          cm->hypotenuse = CHOLMOD_NAME(hypot);
+
+          cm->final_ll = true;
+
+          cholmod_sparse Astore;
+          cholmod_sparse *A = &Astore;
+          double dummy;
+          A->nrow = nr;
+          A->ncol = nc;
+
+          A->p = cidx();
+          A->i = ridx();
+          A->nzmax = nnz();
+          A->packed = true;
+          A->sorted = true;
+          A->nz = 0;
 #ifdef IDX_TYPE_LONG
-	  A->itype = CHOLMOD_LONG;
+          A->itype = CHOLMOD_LONG;
 #else
-	  A->itype = CHOLMOD_INT;
+          A->itype = CHOLMOD_INT;
 #endif
-	  A->dtype = CHOLMOD_DOUBLE;
-	  A->stype = 1;
-	  A->xtype = CHOLMOD_REAL;
-
-	  if (nr < 1)
-	    A->x = &dummy;
-	  else
-	    A->x = data();
-
-	  cholmod_sparse Bstore;
-	  cholmod_sparse *B = &Bstore;
-	  B->nrow = b.rows();
-	  B->ncol = b.cols();
-	  B->p = b.cidx();
-	  B->i = b.ridx();
-	  B->nzmax = b.nnz();
-	  B->packed = true;
-	  B->sorted = true;
-	  B->nz = 0;
+          A->dtype = CHOLMOD_DOUBLE;
+          A->stype = 1;
+          A->xtype = CHOLMOD_REAL;
+
+          if (nr < 1)
+            A->x = &dummy;
+          else
+            A->x = data();
+
+          cholmod_sparse Bstore;
+          cholmod_sparse *B = &Bstore;
+          B->nrow = b.rows();
+          B->ncol = b.cols();
+          B->p = b.cidx();
+          B->i = b.ridx();
+          B->nzmax = b.nnz();
+          B->packed = true;
+          B->sorted = true;
+          B->nz = 0;
 #ifdef IDX_TYPE_LONG
-	  B->itype = CHOLMOD_LONG;
+          B->itype = CHOLMOD_LONG;
 #else
-	  B->itype = CHOLMOD_INT;
+          B->itype = CHOLMOD_INT;
 #endif
-	  B->dtype = CHOLMOD_DOUBLE;
-	  B->stype = 0;
-	  B->xtype = CHOLMOD_REAL;
-
-	  if (b.rows() < 1 || b.cols() < 1)
-	    B->x = &dummy;
-	  else
-	    B->x = b.data();
-
-	  cholmod_factor *L;
-	  BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	  L = CHOLMOD_NAME(analyze) (A, cm);
-	  CHOLMOD_NAME(factorize) (A, L, cm);
-	  if (calc_cond)
-	    rcond = CHOLMOD_NAME(rcond)(L, cm);
-	  else
-	    rcond = 1.;
-	  END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	  if (rcond == 0.0)
-	    {
-	      // Either its indefinite or singular. Try UMFPACK
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Full;
-	    }
-	  else
-	    {
-	      volatile double rcond_plus_one = rcond + 1.0;
-
-	      if (rcond_plus_one == 1.0 || xisnan (rcond))
-		{
-		  err = -2;
-
-		  if (sing_handler)
-		    {
-		      sing_handler (rcond);
-		      mattype.mark_as_rectangular ();
-		    }
-		  else
-		    (*current_liboctave_error_handler)
-		      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		       rcond);
-	      
-		  return retval;
-		}
-
-	      cholmod_sparse *X;
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      X = CHOLMOD_NAME(spsolve) (CHOLMOD_A, L, B, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	      retval = SparseMatrix (static_cast<octave_idx_type>(X->nrow), 
-				     static_cast<octave_idx_type>(X->ncol),
-				     static_cast<octave_idx_type>(X->nzmax));
-	      for (octave_idx_type j = 0; 
-		   j <= static_cast<octave_idx_type>(X->ncol); j++)
-		retval.xcidx(j) = static_cast<octave_idx_type *>(X->p)[j];
-	      for (octave_idx_type j = 0; 
-		   j < static_cast<octave_idx_type>(X->nzmax); j++)
-		{
-		  retval.xridx(j) = static_cast<octave_idx_type *>(X->i)[j];
-		  retval.xdata(j) = static_cast<double *>(X->x)[j];
-		}
-
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      CHOLMOD_NAME(free_sparse) (&X, cm);
-	      CHOLMOD_NAME(free_factor) (&L, cm);
-	      CHOLMOD_NAME(finish) (cm);
-	      static char tmp[] = " ";
-	      CHOLMOD_NAME(print_common) (tmp, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	    }
+          B->dtype = CHOLMOD_DOUBLE;
+          B->stype = 0;
+          B->xtype = CHOLMOD_REAL;
+
+          if (b.rows() < 1 || b.cols() < 1)
+            B->x = &dummy;
+          else
+            B->x = b.data();
+
+          cholmod_factor *L;
+          BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+          L = CHOLMOD_NAME(analyze) (A, cm);
+          CHOLMOD_NAME(factorize) (A, L, cm);
+          if (calc_cond)
+            rcond = CHOLMOD_NAME(rcond)(L, cm);
+          else
+            rcond = 1.;
+          END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+          if (rcond == 0.0)
+            {
+              // Either its indefinite or singular. Try UMFPACK
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Full;
+            }
+          else
+            {
+              volatile double rcond_plus_one = rcond + 1.0;
+
+              if (rcond_plus_one == 1.0 || xisnan (rcond))
+                {
+                  err = -2;
+
+                  if (sing_handler)
+                    {
+                      sing_handler (rcond);
+                      mattype.mark_as_rectangular ();
+                    }
+                  else
+                    (*current_liboctave_error_handler)
+                      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                       rcond);
+              
+                  return retval;
+                }
+
+              cholmod_sparse *X;
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              X = CHOLMOD_NAME(spsolve) (CHOLMOD_A, L, B, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+              retval = SparseMatrix (static_cast<octave_idx_type>(X->nrow), 
+                                     static_cast<octave_idx_type>(X->ncol),
+                                     static_cast<octave_idx_type>(X->nzmax));
+              for (octave_idx_type j = 0; 
+                   j <= static_cast<octave_idx_type>(X->ncol); j++)
+                retval.xcidx(j) = static_cast<octave_idx_type *>(X->p)[j];
+              for (octave_idx_type j = 0; 
+                   j < static_cast<octave_idx_type>(X->nzmax); j++)
+                {
+                  retval.xridx(j) = static_cast<octave_idx_type *>(X->i)[j];
+                  retval.xdata(j) = static_cast<double *>(X->x)[j];
+                }
+
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              CHOLMOD_NAME(free_sparse) (&X, cm);
+              CHOLMOD_NAME(free_factor) (&L, cm);
+              CHOLMOD_NAME(finish) (cm);
+              static char tmp[] = " ";
+              CHOLMOD_NAME(print_common) (tmp, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+            }
 #else
-	  (*current_liboctave_warning_handler)
-	    ("CHOLMOD not installed");
-
-	  mattype.mark_as_unsymmetric ();
-	  typ = MatrixType::Full;
+          (*current_liboctave_warning_handler)
+            ("CHOLMOD not installed");
+
+          mattype.mark_as_unsymmetric ();
+          typ = MatrixType::Full;
 #endif
-	}
+        }
 
       if (typ == MatrixType::Full)
-	{
+        {
 #ifdef HAVE_UMFPACK
-	  Matrix Control, Info;
-	  void *Numeric = factorize (err, rcond, Control, Info, 
-				     sing_handler, calc_cond);
-
-	  if (err == 0)
-	    {
-	      octave_idx_type b_nr = b.rows ();
-	      octave_idx_type b_nc = b.cols ();
-	      int status = 0;
-	      double *control = Control.fortran_vec ();
-	      double *info = Info.fortran_vec ();
-	      const octave_idx_type *Ap = cidx ();
-	      const octave_idx_type *Ai = ridx ();
-	      const double *Ax = data ();
-
-	      OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-	      OCTAVE_LOCAL_BUFFER (double, Xx, b_nr);
-
-	      // Take a first guess that the number of non-zero terms
-	      // will be as many as in b
-	      octave_idx_type x_nz = b.nnz ();
-	      octave_idx_type ii = 0;
-	      retval = SparseMatrix (b_nr, b_nc, x_nz);
-
-	      retval.xcidx(0) = 0;
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    Bx[i] = b.elem (i, j);
-
-		  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap, 
-					     Ai, Ax, Xx, Bx, Numeric, control, 
-					     info);
-		  if (status < 0)
-		    {
-		      (*current_liboctave_error_handler) 
-			("SparseMatrix::solve solve failed");
-
-		      UMFPACK_DNAME (report_status) (control, status);
-		  
-		      err = -1;
-
-		      break;
-		    }
-	      
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    {
-		      double tmp = Xx[i];
-		      if (tmp != 0.0)
-			{
-			  if (ii == x_nz)
-			    {
-			      // Resize the sparse matrix
-			      octave_idx_type sz = x_nz * (b_nc - j) / b_nc;
-			      sz = (sz > 10 ? sz : 10) + x_nz;
-			      retval.change_capacity (sz);
-			      x_nz = sz;
-			    }
-			  retval.xdata(ii) = tmp;
-			  retval.xridx(ii++) = i;
-			}
-		    }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      UMFPACK_DNAME (report_info) (control, info);
-
-	      UMFPACK_DNAME (free_numeric) (&Numeric);
-	    }
-	  else
-	    mattype.mark_as_rectangular ();
+          Matrix Control, Info;
+          void *Numeric = factorize (err, rcond, Control, Info, 
+                                     sing_handler, calc_cond);
+
+          if (err == 0)
+            {
+              octave_idx_type b_nr = b.rows ();
+              octave_idx_type b_nc = b.cols ();
+              int status = 0;
+              double *control = Control.fortran_vec ();
+              double *info = Info.fortran_vec ();
+              const octave_idx_type *Ap = cidx ();
+              const octave_idx_type *Ai = ridx ();
+              const double *Ax = data ();
+
+              OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+              OCTAVE_LOCAL_BUFFER (double, Xx, b_nr);
+
+              // Take a first guess that the number of non-zero terms
+              // will be as many as in b
+              octave_idx_type x_nz = b.nnz ();
+              octave_idx_type ii = 0;
+              retval = SparseMatrix (b_nr, b_nc, x_nz);
+
+              retval.xcidx(0) = 0;
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    Bx[i] = b.elem (i, j);
+
+                  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap, 
+                                             Ai, Ax, Xx, Bx, Numeric, control, 
+                                             info);
+                  if (status < 0)
+                    {
+                      (*current_liboctave_error_handler) 
+                        ("SparseMatrix::solve solve failed");
+
+                      UMFPACK_DNAME (report_status) (control, status);
+                  
+                      err = -1;
+
+                      break;
+                    }
+              
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    {
+                      double tmp = Xx[i];
+                      if (tmp != 0.0)
+                        {
+                          if (ii == x_nz)
+                            {
+                              // Resize the sparse matrix
+                              octave_idx_type sz = x_nz * (b_nc - j) / b_nc;
+                              sz = (sz > 10 ? sz : 10) + x_nz;
+                              retval.change_capacity (sz);
+                              x_nz = sz;
+                            }
+                          retval.xdata(ii) = tmp;
+                          retval.xridx(ii++) = i;
+                        }
+                    }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              UMFPACK_DNAME (report_info) (control, info);
+
+              UMFPACK_DNAME (free_numeric) (&Numeric);
+            }
+          else
+            mattype.mark_as_rectangular ();
 
 #else
-	  (*current_liboctave_error_handler) ("UMFPACK not installed");
+          (*current_liboctave_error_handler) ("UMFPACK not installed");
 #endif
-	}
+        }
       else if (typ != MatrixType::Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
   
   return retval;
@@ -6283,9 +6283,9 @@
 
 ComplexMatrix
 SparseMatrix::fsolve (MatrixType &mattype, const ComplexMatrix& b, 
-		      octave_idx_type& err, double& rcond,
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond,
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   ComplexMatrix retval;
 
@@ -6305,211 +6305,211 @@
       mattype.info ();
 
       if (typ == MatrixType::Hermitian)
-	{
+        {
 #ifdef HAVE_CHOLMOD
-	  cholmod_common Common;
-	  cholmod_common *cm = &Common;
-
-	  // Setup initial parameters
-	  CHOLMOD_NAME(start) (cm);
-	  cm->prefer_zomplex = false;
-
-	  double spu = octave_sparse_params::get_key ("spumoni");
-	  if (spu == 0.)
-	    {
-	      cm->print = -1;
-	      cm->print_function = 0;
-	    }
-	  else
-	    {
-	      cm->print = static_cast<int> (spu) + 2;
-	      cm->print_function =&SparseCholPrint;
-	    }
-
-	  cm->error_handler = &SparseCholError;
-	  cm->complex_divide = CHOLMOD_NAME(divcomplex);
-	  cm->hypotenuse = CHOLMOD_NAME(hypot);
-
-	  cm->final_ll = true;
-
-	  cholmod_sparse Astore;
-	  cholmod_sparse *A = &Astore;
-	  double dummy;
-	  A->nrow = nr;
-	  A->ncol = nc;
-
-	  A->p = cidx();
-	  A->i = ridx();
-	  A->nzmax = nnz();
-	  A->packed = true;
-	  A->sorted = true;
-	  A->nz = 0;
+          cholmod_common Common;
+          cholmod_common *cm = &Common;
+
+          // Setup initial parameters
+          CHOLMOD_NAME(start) (cm);
+          cm->prefer_zomplex = false;
+
+          double spu = octave_sparse_params::get_key ("spumoni");
+          if (spu == 0.)
+            {
+              cm->print = -1;
+              cm->print_function = 0;
+            }
+          else
+            {
+              cm->print = static_cast<int> (spu) + 2;
+              cm->print_function =&SparseCholPrint;
+            }
+
+          cm->error_handler = &SparseCholError;
+          cm->complex_divide = CHOLMOD_NAME(divcomplex);
+          cm->hypotenuse = CHOLMOD_NAME(hypot);
+
+          cm->final_ll = true;
+
+          cholmod_sparse Astore;
+          cholmod_sparse *A = &Astore;
+          double dummy;
+          A->nrow = nr;
+          A->ncol = nc;
+
+          A->p = cidx();
+          A->i = ridx();
+          A->nzmax = nnz();
+          A->packed = true;
+          A->sorted = true;
+          A->nz = 0;
 #ifdef IDX_TYPE_LONG
-	  A->itype = CHOLMOD_LONG;
+          A->itype = CHOLMOD_LONG;
 #else
-	  A->itype = CHOLMOD_INT;
+          A->itype = CHOLMOD_INT;
 #endif
-	  A->dtype = CHOLMOD_DOUBLE;
-	  A->stype = 1;
-	  A->xtype = CHOLMOD_REAL;
-
-	  if (nr < 1)
-	    A->x = &dummy;
-	  else
-	    A->x = data();
-
-	  cholmod_dense Bstore;
-	  cholmod_dense *B = &Bstore;
-	  B->nrow = b.rows();
-	  B->ncol = b.cols();
-	  B->d = B->nrow;
-	  B->nzmax = B->nrow * B->ncol;
-	  B->dtype = CHOLMOD_DOUBLE;
-	  B->xtype = CHOLMOD_COMPLEX;
-	  if (nc < 1 || b.cols() < 1)
-	    B->x = &dummy;
-	  else
-	    // We won't alter it, honest :-)
-	    B->x = const_cast<Complex *>(b.fortran_vec());
-
-	  cholmod_factor *L;
-	  BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	  L = CHOLMOD_NAME(analyze) (A, cm);
-	  CHOLMOD_NAME(factorize) (A, L, cm);
-	  if (calc_cond)
-	    rcond = CHOLMOD_NAME(rcond)(L, cm);
-	  else
-	    rcond = 1.0;
-	  END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	  if (rcond == 0.0)
-	    {
-	      // Either its indefinite or singular. Try UMFPACK
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Full;
-	    }
-	  else
-	    {
-	      volatile double rcond_plus_one = rcond + 1.0;
-
-	      if (rcond_plus_one == 1.0 || xisnan (rcond))
-		{
-		  err = -2;
-
-		  if (sing_handler)
-		    {
-		      sing_handler (rcond);
-		      mattype.mark_as_rectangular ();
-		    }
-		  else
-		    (*current_liboctave_error_handler)
-		      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		       rcond);
-	      
-		  return retval;
-		}
-
-	      cholmod_dense *X;
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      X = CHOLMOD_NAME(solve) (CHOLMOD_A, L, B, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	      retval.resize (b.rows (), b.cols());
-	      for (octave_idx_type j = 0; j < b.cols(); j++)
-		{
-		  octave_idx_type jr = j * b.rows();
-		  for (octave_idx_type i = 0; i < b.rows(); i++)
-		    retval.xelem(i,j) = static_cast<Complex *>(X->x)[jr + i];
-		}
-
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      CHOLMOD_NAME(free_dense) (&X, cm);
-	      CHOLMOD_NAME(free_factor) (&L, cm);
-	      CHOLMOD_NAME(finish) (cm);
-	      static char tmp[] = " ";
-	      CHOLMOD_NAME(print_common) (tmp, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	    }
+          A->dtype = CHOLMOD_DOUBLE;
+          A->stype = 1;
+          A->xtype = CHOLMOD_REAL;
+
+          if (nr < 1)
+            A->x = &dummy;
+          else
+            A->x = data();
+
+          cholmod_dense Bstore;
+          cholmod_dense *B = &Bstore;
+          B->nrow = b.rows();
+          B->ncol = b.cols();
+          B->d = B->nrow;
+          B->nzmax = B->nrow * B->ncol;
+          B->dtype = CHOLMOD_DOUBLE;
+          B->xtype = CHOLMOD_COMPLEX;
+          if (nc < 1 || b.cols() < 1)
+            B->x = &dummy;
+          else
+            // We won't alter it, honest :-)
+            B->x = const_cast<Complex *>(b.fortran_vec());
+
+          cholmod_factor *L;
+          BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+          L = CHOLMOD_NAME(analyze) (A, cm);
+          CHOLMOD_NAME(factorize) (A, L, cm);
+          if (calc_cond)
+            rcond = CHOLMOD_NAME(rcond)(L, cm);
+          else
+            rcond = 1.0;
+          END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+          if (rcond == 0.0)
+            {
+              // Either its indefinite or singular. Try UMFPACK
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Full;
+            }
+          else
+            {
+              volatile double rcond_plus_one = rcond + 1.0;
+
+              if (rcond_plus_one == 1.0 || xisnan (rcond))
+                {
+                  err = -2;
+
+                  if (sing_handler)
+                    {
+                      sing_handler (rcond);
+                      mattype.mark_as_rectangular ();
+                    }
+                  else
+                    (*current_liboctave_error_handler)
+                      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                       rcond);
+              
+                  return retval;
+                }
+
+              cholmod_dense *X;
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              X = CHOLMOD_NAME(solve) (CHOLMOD_A, L, B, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+              retval.resize (b.rows (), b.cols());
+              for (octave_idx_type j = 0; j < b.cols(); j++)
+                {
+                  octave_idx_type jr = j * b.rows();
+                  for (octave_idx_type i = 0; i < b.rows(); i++)
+                    retval.xelem(i,j) = static_cast<Complex *>(X->x)[jr + i];
+                }
+
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              CHOLMOD_NAME(free_dense) (&X, cm);
+              CHOLMOD_NAME(free_factor) (&L, cm);
+              CHOLMOD_NAME(finish) (cm);
+              static char tmp[] = " ";
+              CHOLMOD_NAME(print_common) (tmp, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+            }
 #else
-	  (*current_liboctave_warning_handler)
-	    ("CHOLMOD not installed");
-
-	  mattype.mark_as_unsymmetric ();
-	  typ = MatrixType::Full;
+          (*current_liboctave_warning_handler)
+            ("CHOLMOD not installed");
+
+          mattype.mark_as_unsymmetric ();
+          typ = MatrixType::Full;
 #endif
-	}
+        }
 
       if (typ == MatrixType::Full)
-	{
+        {
 #ifdef HAVE_UMFPACK
-	  Matrix Control, Info;
-	  void *Numeric = factorize (err, rcond, Control, Info, 
-				     sing_handler, calc_cond);
-
-	  if (err == 0)
-	    {
-	      octave_idx_type b_nr = b.rows ();
-	      octave_idx_type b_nc = b.cols ();
-	      int status = 0;
-	      double *control = Control.fortran_vec ();
-	      double *info = Info.fortran_vec ();
-	      const octave_idx_type *Ap = cidx ();
-	      const octave_idx_type *Ai = ridx ();
-	      const double *Ax = data ();
-
-	      OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-	      OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
-
-	      retval.resize (b_nr, b_nc);
-
-	      OCTAVE_LOCAL_BUFFER (double, Xx, b_nr);
-	      OCTAVE_LOCAL_BUFFER (double, Xz, b_nr);
-	      
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    {
-		      Complex c = b (i,j);
-		      Bx[i] = std::real (c);
-		      Bz[i] = std::imag (c);
-		    }
-
-		  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap, 
-					     Ai, Ax, Xx, Bx, Numeric, control, 
-					     info);
-		  int status2 = UMFPACK_DNAME (solve) (UMFPACK_A,
-						  Ap, Ai, Ax, Xz, Bz, Numeric, 
-						  control, info) ;
-
-		  if (status < 0 || status2 < 0)
-		    {
-		      (*current_liboctave_error_handler) 
-			("SparseMatrix::solve solve failed");
-
-		      UMFPACK_DNAME (report_status) (control, status);
-		      
-		      err = -1;
-
-		      break;
-		    }
-
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    retval (i, j) = Complex (Xx[i], Xz[i]);
-		}
-
-	      UMFPACK_DNAME (report_info) (control, info);
-
-	      UMFPACK_DNAME (free_numeric) (&Numeric);
-	    }
-	  else
-	    mattype.mark_as_rectangular ();
+          Matrix Control, Info;
+          void *Numeric = factorize (err, rcond, Control, Info, 
+                                     sing_handler, calc_cond);
+
+          if (err == 0)
+            {
+              octave_idx_type b_nr = b.rows ();
+              octave_idx_type b_nc = b.cols ();
+              int status = 0;
+              double *control = Control.fortran_vec ();
+              double *info = Info.fortran_vec ();
+              const octave_idx_type *Ap = cidx ();
+              const octave_idx_type *Ai = ridx ();
+              const double *Ax = data ();
+
+              OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+              OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
+
+              retval.resize (b_nr, b_nc);
+
+              OCTAVE_LOCAL_BUFFER (double, Xx, b_nr);
+              OCTAVE_LOCAL_BUFFER (double, Xz, b_nr);
+              
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    {
+                      Complex c = b (i,j);
+                      Bx[i] = std::real (c);
+                      Bz[i] = std::imag (c);
+                    }
+
+                  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap, 
+                                             Ai, Ax, Xx, Bx, Numeric, control, 
+                                             info);
+                  int status2 = UMFPACK_DNAME (solve) (UMFPACK_A,
+                                                  Ap, Ai, Ax, Xz, Bz, Numeric, 
+                                                  control, info) ;
+
+                  if (status < 0 || status2 < 0)
+                    {
+                      (*current_liboctave_error_handler) 
+                        ("SparseMatrix::solve solve failed");
+
+                      UMFPACK_DNAME (report_status) (control, status);
+                      
+                      err = -1;
+
+                      break;
+                    }
+
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    retval (i, j) = Complex (Xx[i], Xz[i]);
+                }
+
+              UMFPACK_DNAME (report_info) (control, info);
+
+              UMFPACK_DNAME (free_numeric) (&Numeric);
+            }
+          else
+            mattype.mark_as_rectangular ();
 
 #else
-	  (*current_liboctave_error_handler) ("UMFPACK not installed");
+          (*current_liboctave_error_handler) ("UMFPACK not installed");
 #endif
-	}
+        }
       else if (typ != MatrixType::Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
   
   return retval;
@@ -6517,9 +6517,9 @@
 
 SparseComplexMatrix
 SparseMatrix::fsolve (MatrixType &mattype, const SparseComplexMatrix& b, 
-		      octave_idx_type& err, double& rcond,
-		      solve_singularity_handler sing_handler,
-		      bool calc_cond) const
+                      octave_idx_type& err, double& rcond,
+                      solve_singularity_handler sing_handler,
+                      bool calc_cond) const
 {
   SparseComplexMatrix retval;
 
@@ -6539,249 +6539,249 @@
       mattype.info ();
 
       if (typ == MatrixType::Hermitian)
-	{
+        {
 #ifdef HAVE_CHOLMOD
-	  cholmod_common Common;
-	  cholmod_common *cm = &Common;
-
-	  // Setup initial parameters
-	  CHOLMOD_NAME(start) (cm);
-	  cm->prefer_zomplex = false;
-
-	  double spu = octave_sparse_params::get_key ("spumoni");
-	  if (spu == 0.)
-	    {
-	      cm->print = -1;
-	      cm->print_function = 0;
-	    }
-	  else
-	    {
-	      cm->print = static_cast<int> (spu) + 2;
-	      cm->print_function =&SparseCholPrint;
-	    }
-
-	  cm->error_handler = &SparseCholError;
-	  cm->complex_divide = CHOLMOD_NAME(divcomplex);
-	  cm->hypotenuse = CHOLMOD_NAME(hypot);
-
-	  cm->final_ll = true;
-
-	  cholmod_sparse Astore;
-	  cholmod_sparse *A = &Astore;
-	  double dummy;
-	  A->nrow = nr;
-	  A->ncol = nc;
-
-	  A->p = cidx();
-	  A->i = ridx();
-	  A->nzmax = nnz();
-	  A->packed = true;
-	  A->sorted = true;
-	  A->nz = 0;
+          cholmod_common Common;
+          cholmod_common *cm = &Common;
+
+          // Setup initial parameters
+          CHOLMOD_NAME(start) (cm);
+          cm->prefer_zomplex = false;
+
+          double spu = octave_sparse_params::get_key ("spumoni");
+          if (spu == 0.)
+            {
+              cm->print = -1;
+              cm->print_function = 0;
+            }
+          else
+            {
+              cm->print = static_cast<int> (spu) + 2;
+              cm->print_function =&SparseCholPrint;
+            }
+
+          cm->error_handler = &SparseCholError;
+          cm->complex_divide = CHOLMOD_NAME(divcomplex);
+          cm->hypotenuse = CHOLMOD_NAME(hypot);
+
+          cm->final_ll = true;
+
+          cholmod_sparse Astore;
+          cholmod_sparse *A = &Astore;
+          double dummy;
+          A->nrow = nr;
+          A->ncol = nc;
+
+          A->p = cidx();
+          A->i = ridx();
+          A->nzmax = nnz();
+          A->packed = true;
+          A->sorted = true;
+          A->nz = 0;
 #ifdef IDX_TYPE_LONG
-	  A->itype = CHOLMOD_LONG;
+          A->itype = CHOLMOD_LONG;
 #else
-	  A->itype = CHOLMOD_INT;
+          A->itype = CHOLMOD_INT;
 #endif
-	  A->dtype = CHOLMOD_DOUBLE;
-	  A->stype = 1;
-	  A->xtype = CHOLMOD_REAL;
-
-	  if (nr < 1)
-	    A->x = &dummy;
-	  else
-	    A->x = data();
-
-	  cholmod_sparse Bstore;
-	  cholmod_sparse *B = &Bstore;
-	  B->nrow = b.rows();
-	  B->ncol = b.cols();
-	  B->p = b.cidx();
-	  B->i = b.ridx();
-	  B->nzmax = b.nnz();
-	  B->packed = true;
-	  B->sorted = true;
-	  B->nz = 0;
+          A->dtype = CHOLMOD_DOUBLE;
+          A->stype = 1;
+          A->xtype = CHOLMOD_REAL;
+
+          if (nr < 1)
+            A->x = &dummy;
+          else
+            A->x = data();
+
+          cholmod_sparse Bstore;
+          cholmod_sparse *B = &Bstore;
+          B->nrow = b.rows();
+          B->ncol = b.cols();
+          B->p = b.cidx();
+          B->i = b.ridx();
+          B->nzmax = b.nnz();
+          B->packed = true;
+          B->sorted = true;
+          B->nz = 0;
 #ifdef IDX_TYPE_LONG
-	  B->itype = CHOLMOD_LONG;
+          B->itype = CHOLMOD_LONG;
 #else
-	  B->itype = CHOLMOD_INT;
+          B->itype = CHOLMOD_INT;
 #endif
-	  B->dtype = CHOLMOD_DOUBLE;
-	  B->stype = 0;
-	  B->xtype = CHOLMOD_COMPLEX;
-
-	  if (b.rows() < 1 || b.cols() < 1)
-	    B->x = &dummy;
-	  else
-	    B->x = b.data();
-
-	  cholmod_factor *L;
-	  BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	  L = CHOLMOD_NAME(analyze) (A, cm);
-	  CHOLMOD_NAME(factorize) (A, L, cm);
-	  if (calc_cond)
-	    rcond = CHOLMOD_NAME(rcond)(L, cm);
-	  else
-	    rcond = 1.0;
-	  END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	  if (rcond == 0.0)
-	    {
-	      // Either its indefinite or singular. Try UMFPACK
-	      mattype.mark_as_unsymmetric ();
-	      typ = MatrixType::Full;
-	    }
-	  else
-	    {
-	      volatile double rcond_plus_one = rcond + 1.0;
-
-	      if (rcond_plus_one == 1.0 || xisnan (rcond))
-		{
-		  err = -2;
-
-		  if (sing_handler)
-		    {
-		      sing_handler (rcond);
-		      mattype.mark_as_rectangular ();
-		    }
-		  else
-		    (*current_liboctave_error_handler)
-		      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
-		       rcond);
-	      
-		  return retval;
-		}
-
-	      cholmod_sparse *X;
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      X = CHOLMOD_NAME(spsolve) (CHOLMOD_A, L, B, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-
-	      retval = SparseComplexMatrix 
-		(static_cast<octave_idx_type>(X->nrow), 
-		 static_cast<octave_idx_type>(X->ncol),
-		 static_cast<octave_idx_type>(X->nzmax));
-	      for (octave_idx_type j = 0; 
-		   j <= static_cast<octave_idx_type>(X->ncol); j++)
-		retval.xcidx(j) = static_cast<octave_idx_type *>(X->p)[j];
-	      for (octave_idx_type j = 0; 
-		   j < static_cast<octave_idx_type>(X->nzmax); j++)
-		{
-		  retval.xridx(j) = static_cast<octave_idx_type *>(X->i)[j];
-		  retval.xdata(j) = static_cast<Complex *>(X->x)[j];
-		}
-
-	      BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	      CHOLMOD_NAME(free_sparse) (&X, cm);
-	      CHOLMOD_NAME(free_factor) (&L, cm);
-	      CHOLMOD_NAME(finish) (cm);
-	      static char tmp[] = " ";
-	      CHOLMOD_NAME(print_common) (tmp, cm);
-	      END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
-	    }
+          B->dtype = CHOLMOD_DOUBLE;
+          B->stype = 0;
+          B->xtype = CHOLMOD_COMPLEX;
+
+          if (b.rows() < 1 || b.cols() < 1)
+            B->x = &dummy;
+          else
+            B->x = b.data();
+
+          cholmod_factor *L;
+          BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+          L = CHOLMOD_NAME(analyze) (A, cm);
+          CHOLMOD_NAME(factorize) (A, L, cm);
+          if (calc_cond)
+            rcond = CHOLMOD_NAME(rcond)(L, cm);
+          else
+            rcond = 1.0;
+          END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+          if (rcond == 0.0)
+            {
+              // Either its indefinite or singular. Try UMFPACK
+              mattype.mark_as_unsymmetric ();
+              typ = MatrixType::Full;
+            }
+          else
+            {
+              volatile double rcond_plus_one = rcond + 1.0;
+
+              if (rcond_plus_one == 1.0 || xisnan (rcond))
+                {
+                  err = -2;
+
+                  if (sing_handler)
+                    {
+                      sing_handler (rcond);
+                      mattype.mark_as_rectangular ();
+                    }
+                  else
+                    (*current_liboctave_error_handler)
+                      ("SparseMatrix::solve matrix singular to machine precision, rcond = %g",
+                       rcond);
+              
+                  return retval;
+                }
+
+              cholmod_sparse *X;
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              X = CHOLMOD_NAME(spsolve) (CHOLMOD_A, L, B, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+
+              retval = SparseComplexMatrix 
+                (static_cast<octave_idx_type>(X->nrow), 
+                 static_cast<octave_idx_type>(X->ncol),
+                 static_cast<octave_idx_type>(X->nzmax));
+              for (octave_idx_type j = 0; 
+                   j <= static_cast<octave_idx_type>(X->ncol); j++)
+                retval.xcidx(j) = static_cast<octave_idx_type *>(X->p)[j];
+              for (octave_idx_type j = 0; 
+                   j < static_cast<octave_idx_type>(X->nzmax); j++)
+                {
+                  retval.xridx(j) = static_cast<octave_idx_type *>(X->i)[j];
+                  retval.xdata(j) = static_cast<Complex *>(X->x)[j];
+                }
+
+              BEGIN_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+              CHOLMOD_NAME(free_sparse) (&X, cm);
+              CHOLMOD_NAME(free_factor) (&L, cm);
+              CHOLMOD_NAME(finish) (cm);
+              static char tmp[] = " ";
+              CHOLMOD_NAME(print_common) (tmp, cm);
+              END_INTERRUPT_IMMEDIATELY_IN_FOREIGN_CODE;
+            }
 #else
-	  (*current_liboctave_warning_handler)
-	    ("CHOLMOD not installed");
-
-	  mattype.mark_as_unsymmetric ();
-	  typ = MatrixType::Full;
+          (*current_liboctave_warning_handler)
+            ("CHOLMOD not installed");
+
+          mattype.mark_as_unsymmetric ();
+          typ = MatrixType::Full;
 #endif
-	}
+        }
 
       if (typ == MatrixType::Full)
-	{
+        {
 #ifdef HAVE_UMFPACK
-	  Matrix Control, Info;
-	  void *Numeric = factorize (err, rcond, Control, Info, 
-				     sing_handler, calc_cond);
-
-	  if (err == 0)
-	    {
-	      octave_idx_type b_nr = b.rows ();
-	      octave_idx_type b_nc = b.cols ();
-	      int status = 0;
-	      double *control = Control.fortran_vec ();
-	      double *info = Info.fortran_vec ();
-	      const octave_idx_type *Ap = cidx ();
-	      const octave_idx_type *Ai = ridx ();
-	      const double *Ax = data ();
-
-	      OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
-	      OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
-
-	      // Take a first guess that the number of non-zero terms
-	      // will be as many as in b
-	      octave_idx_type x_nz = b.nnz ();
-	      octave_idx_type ii = 0;
-	      retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
-
-	      OCTAVE_LOCAL_BUFFER (double, Xx, b_nr);
-	      OCTAVE_LOCAL_BUFFER (double, Xz, b_nr);
-	      
-	      retval.xcidx(0) = 0;
-	      for (octave_idx_type j = 0; j < b_nc; j++)
-		{
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    {
-		      Complex c = b (i,j);
-		      Bx[i] = std::real (c);
-		      Bz[i] = std::imag (c);
-		    }
-
-		  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap,
-					     Ai, Ax, Xx, Bx, Numeric, control, 
-					     info);
-		  int status2 = UMFPACK_DNAME (solve) (UMFPACK_A,
-						  Ap, Ai, Ax, Xz, Bz, Numeric, 
-						  control, info) ;
-
-		  if (status < 0 || status2 < 0)
-		    {
-		      (*current_liboctave_error_handler) 
-			("SparseMatrix::solve solve failed");
-
-		      UMFPACK_DNAME (report_status) (control, status);
-		      
-		      err = -1;
-
-		      break;
-		    }
-
-		  for (octave_idx_type i = 0; i < b_nr; i++)
-		    {
-		      Complex tmp = Complex (Xx[i], Xz[i]);
-		      if (tmp != 0.0)
-			{
-			  if (ii == x_nz)
-			    {
-			      // Resize the sparse matrix
-			      octave_idx_type sz = x_nz * (b_nc - j) / b_nc;
-			      sz = (sz > 10 ? sz : 10) + x_nz;
-			      retval.change_capacity (sz);
-			      x_nz = sz;
-			    }
-			  retval.xdata(ii) = tmp;
-			  retval.xridx(ii++) = i;
-			}
-		    }
-		  retval.xcidx(j+1) = ii;
-		}
-
-	      retval.maybe_compress ();
-
-	      UMFPACK_DNAME (report_info) (control, info);
-
-	      UMFPACK_DNAME (free_numeric) (&Numeric);
-	    }
-	  else
-	    mattype.mark_as_rectangular ();
+          Matrix Control, Info;
+          void *Numeric = factorize (err, rcond, Control, Info, 
+                                     sing_handler, calc_cond);
+
+          if (err == 0)
+            {
+              octave_idx_type b_nr = b.rows ();
+              octave_idx_type b_nc = b.cols ();
+              int status = 0;
+              double *control = Control.fortran_vec ();
+              double *info = Info.fortran_vec ();
+              const octave_idx_type *Ap = cidx ();
+              const octave_idx_type *Ai = ridx ();
+              const double *Ax = data ();
+
+              OCTAVE_LOCAL_BUFFER (double, Bx, b_nr);
+              OCTAVE_LOCAL_BUFFER (double, Bz, b_nr);
+
+              // Take a first guess that the number of non-zero terms
+              // will be as many as in b
+              octave_idx_type x_nz = b.nnz ();
+              octave_idx_type ii = 0;
+              retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
+
+              OCTAVE_LOCAL_BUFFER (double, Xx, b_nr);
+              OCTAVE_LOCAL_BUFFER (double, Xz, b_nr);
+              
+              retval.xcidx(0) = 0;
+              for (octave_idx_type j = 0; j < b_nc; j++)
+                {
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    {
+                      Complex c = b (i,j);
+                      Bx[i] = std::real (c);
+                      Bz[i] = std::imag (c);
+                    }
+
+                  status = UMFPACK_DNAME (solve) (UMFPACK_A, Ap,
+                                             Ai, Ax, Xx, Bx, Numeric, control, 
+                                             info);
+                  int status2 = UMFPACK_DNAME (solve) (UMFPACK_A,
+                                                  Ap, Ai, Ax, Xz, Bz, Numeric, 
+                                                  control, info) ;
+
+                  if (status < 0 || status2 < 0)
+                    {
+                      (*current_liboctave_error_handler) 
+                        ("SparseMatrix::solve solve failed");
+
+                      UMFPACK_DNAME (report_status) (control, status);
+                      
+                      err = -1;
+
+                      break;
+                    }
+
+                  for (octave_idx_type i = 0; i < b_nr; i++)
+                    {
+                      Complex tmp = Complex (Xx[i], Xz[i]);
+                      if (tmp != 0.0)
+                        {
+                          if (ii == x_nz)
+                            {
+                              // Resize the sparse matrix
+                              octave_idx_type sz = x_nz * (b_nc - j) / b_nc;
+                              sz = (sz > 10 ? sz : 10) + x_nz;
+                              retval.change_capacity (sz);
+                              x_nz = sz;
+                            }
+                          retval.xdata(ii) = tmp;
+                          retval.xridx(ii++) = i;
+                        }
+                    }
+                  retval.xcidx(j+1) = ii;
+                }
+
+              retval.maybe_compress ();
+
+              UMFPACK_DNAME (report_info) (control, info);
+
+              UMFPACK_DNAME (free_numeric) (&Numeric);
+            }
+          else
+            mattype.mark_as_rectangular ();
 #else
-	  (*current_liboctave_error_handler) ("UMFPACK not installed");
+          (*current_liboctave_error_handler) ("UMFPACK not installed");
 #endif
-	}
+        }
       else if (typ != MatrixType::Hermitian)
-	(*current_liboctave_error_handler) ("incorrect matrix type");
+        (*current_liboctave_error_handler) ("incorrect matrix type");
     }
   
   return retval;
@@ -6797,7 +6797,7 @@
 
 Matrix
 SparseMatrix::solve (MatrixType &mattype, const Matrix& b, 
-		     octave_idx_type& info) const
+                     octave_idx_type& info) const
 {
   double rcond;
   return solve (mattype, b, info, rcond, 0);
@@ -6805,15 +6805,15 @@
 
 Matrix
 SparseMatrix::solve (MatrixType &mattype, const Matrix& b, octave_idx_type& info, 
-		     double& rcond) const
+                     double& rcond) const
 {
   return solve (mattype, b, info, rcond, 0);
 }
 
 Matrix
 SparseMatrix::solve (MatrixType &mattype, const Matrix& b, octave_idx_type& err, 
-		     double& rcond, solve_singularity_handler sing_handler,
-		     bool singular_fallback) const
+                     double& rcond, solve_singularity_handler sing_handler,
+                     bool singular_fallback) const
 {
   Matrix retval;
   int typ = mattype.type (false);
@@ -6831,7 +6831,7 @@
   else if (typ == MatrixType::Banded || typ == MatrixType::Banded_Hermitian)
     retval = bsolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Tridiagonal || 
-	   typ == MatrixType::Tridiagonal_Hermitian)
+           typ == MatrixType::Tridiagonal_Hermitian)
     retval = trisolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Full || typ == MatrixType::Hermitian)
     retval = fsolve (mattype, b, err, rcond, sing_handler, true);
@@ -6865,7 +6865,7 @@
 
 SparseMatrix
 SparseMatrix::solve (MatrixType &mattype, const SparseMatrix& b, 
-		     octave_idx_type& info) const
+                     octave_idx_type& info) const
 {
   double rcond;
   return solve (mattype, b, info, rcond, 0);
@@ -6873,16 +6873,16 @@
 
 SparseMatrix
 SparseMatrix::solve (MatrixType &mattype, const SparseMatrix& b,
-		     octave_idx_type& info, double& rcond) const
+                     octave_idx_type& info, double& rcond) const
 {
   return solve (mattype, b, info, rcond, 0);
 }
 
 SparseMatrix
 SparseMatrix::solve (MatrixType &mattype, const SparseMatrix& b, 
-		     octave_idx_type& err, double& rcond,
-		     solve_singularity_handler sing_handler,
-		     bool singular_fallback) const
+                     octave_idx_type& err, double& rcond,
+                     solve_singularity_handler sing_handler,
+                     bool singular_fallback) const
 {
   SparseMatrix retval;
   int typ = mattype.type (false);
@@ -6899,7 +6899,7 @@
   else if (typ == MatrixType::Banded || typ == MatrixType::Banded_Hermitian)
     retval = bsolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Tridiagonal || 
-	   typ == MatrixType::Tridiagonal_Hermitian)
+           typ == MatrixType::Tridiagonal_Hermitian)
     retval = trisolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Full || typ == MatrixType::Hermitian)
     retval = fsolve (mattype, b, err, rcond, sing_handler, true);
@@ -6916,7 +6916,7 @@
       retval = qrsolve (*this, b, err);
 #else
       retval = dmsolve<SparseMatrix, SparseMatrix, 
-	SparseMatrix> (*this, b, err);
+        SparseMatrix> (*this, b, err);
 #endif
     }
 
@@ -6933,7 +6933,7 @@
 
 ComplexMatrix
 SparseMatrix::solve (MatrixType &mattype, const ComplexMatrix& b, 
-			    octave_idx_type& info) const
+                            octave_idx_type& info) const
 {
   double rcond;
   return solve (mattype, b, info, rcond, 0);
@@ -6941,16 +6941,16 @@
 
 ComplexMatrix
 SparseMatrix::solve (MatrixType &mattype, const ComplexMatrix& b, 
-		     octave_idx_type& info, double& rcond) const
+                     octave_idx_type& info, double& rcond) const
 {
   return solve (mattype, b, info, rcond, 0);
 }
 
 ComplexMatrix
 SparseMatrix::solve (MatrixType &mattype, const ComplexMatrix& b, 
-		     octave_idx_type& err, double& rcond, 
-		     solve_singularity_handler sing_handler,
-		     bool singular_fallback) const
+                     octave_idx_type& err, double& rcond, 
+                     solve_singularity_handler sing_handler,
+                     bool singular_fallback) const
 {
   ComplexMatrix retval;
   int typ = mattype.type (false);
@@ -6967,7 +6967,7 @@
   else if (typ == MatrixType::Banded || typ == MatrixType::Banded_Hermitian)
     retval = bsolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Tridiagonal || 
-	   typ == MatrixType::Tridiagonal_Hermitian)
+           typ == MatrixType::Tridiagonal_Hermitian)
     retval = trisolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Full || typ == MatrixType::Hermitian)
     retval = fsolve (mattype, b, err, rcond, sing_handler, true);
@@ -6984,7 +6984,7 @@
       retval = qrsolve (*this, b, err);
 #else
       retval = dmsolve<ComplexMatrix, SparseMatrix, 
-	ComplexMatrix> (*this, b, err);
+        ComplexMatrix> (*this, b, err);
 #endif
     }
 
@@ -7001,7 +7001,7 @@
 
 SparseComplexMatrix
 SparseMatrix::solve (MatrixType &mattype, const SparseComplexMatrix& b, 
-		     octave_idx_type& info) const
+                     octave_idx_type& info) const
 {
   double rcond;
   return solve (mattype, b, info, rcond, 0);
@@ -7009,16 +7009,16 @@
 
 SparseComplexMatrix
 SparseMatrix::solve (MatrixType &mattype, const SparseComplexMatrix& b,
-		     octave_idx_type& info, double& rcond) const
+                     octave_idx_type& info, double& rcond) const
 {
   return solve (mattype, b, info, rcond, 0);
 }
 
 SparseComplexMatrix
 SparseMatrix::solve (MatrixType &mattype, const SparseComplexMatrix& b, 
-		     octave_idx_type& err, double& rcond,
-		     solve_singularity_handler sing_handler,
-		     bool singular_fallback) const
+                     octave_idx_type& err, double& rcond,
+                     solve_singularity_handler sing_handler,
+                     bool singular_fallback) const
 {
   SparseComplexMatrix retval;
   int typ = mattype.type (false);
@@ -7035,7 +7035,7 @@
   else if (typ == MatrixType::Banded || typ == MatrixType::Banded_Hermitian)
     retval = bsolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Tridiagonal || 
-	   typ == MatrixType::Tridiagonal_Hermitian)
+           typ == MatrixType::Tridiagonal_Hermitian)
     retval = trisolve (mattype, b, err, rcond, sing_handler, false);
   else if (typ == MatrixType::Full || typ == MatrixType::Hermitian)
     retval = fsolve (mattype, b, err, rcond, sing_handler, true);
@@ -7052,7 +7052,7 @@
       retval = qrsolve (*this, b, err);
 #else
       retval = dmsolve<SparseComplexMatrix, SparseMatrix, 
-	SparseComplexMatrix> (*this, b, err);
+        SparseComplexMatrix> (*this, b, err);
 #endif
     }
 
@@ -7081,7 +7081,7 @@
 
 ColumnVector
 SparseMatrix::solve (MatrixType &mattype, const ColumnVector& b, octave_idx_type& info, double& rcond,
-	       solve_singularity_handler sing_handler) const
+               solve_singularity_handler sing_handler) const
 {
   Matrix tmp (b);
   return solve (mattype, tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
@@ -7104,14 +7104,14 @@
 
 ComplexColumnVector
 SparseMatrix::solve (MatrixType &mattype, const ComplexColumnVector& b, octave_idx_type& info, 
-		     double& rcond) const
+                     double& rcond) const
 {
   return solve (mattype, b, info, rcond, 0);
 }
 
 ComplexColumnVector
 SparseMatrix::solve (MatrixType &mattype, const ComplexColumnVector& b, octave_idx_type& info, double& rcond,
-	       solve_singularity_handler sing_handler) const
+               solve_singularity_handler sing_handler) const
 {
   ComplexMatrix tmp (b);
   return solve (mattype, tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
@@ -7134,15 +7134,15 @@
 
 Matrix
 SparseMatrix::solve (const Matrix& b, octave_idx_type& info, 
-		     double& rcond) const
+                     double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 Matrix
 SparseMatrix::solve (const Matrix& b, octave_idx_type& err, 
-		     double& rcond, 
-		     solve_singularity_handler sing_handler) const
+                     double& rcond, 
+                     solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7158,7 +7158,7 @@
 
 SparseMatrix
 SparseMatrix::solve (const SparseMatrix& b, 
-		     octave_idx_type& info) const
+                     octave_idx_type& info) const
 {
   double rcond;
   return solve (b, info, rcond, 0);
@@ -7166,15 +7166,15 @@
 
 SparseMatrix
 SparseMatrix::solve (const SparseMatrix& b,
-		     octave_idx_type& info, double& rcond) const
+                     octave_idx_type& info, double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 SparseMatrix
 SparseMatrix::solve (const SparseMatrix& b, 
-		     octave_idx_type& err, double& rcond,
-		     solve_singularity_handler sing_handler) const
+                     octave_idx_type& err, double& rcond,
+                     solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7182,7 +7182,7 @@
 
 ComplexMatrix
 SparseMatrix::solve (const ComplexMatrix& b, 
-			    octave_idx_type& info) const
+                            octave_idx_type& info) const
 {
   double rcond;
   return solve (b, info, rcond, 0);
@@ -7190,15 +7190,15 @@
 
 ComplexMatrix
 SparseMatrix::solve (const ComplexMatrix& b, 
-		     octave_idx_type& info, double& rcond) const
+                     octave_idx_type& info, double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 ComplexMatrix
 SparseMatrix::solve (const ComplexMatrix& b, 
-		     octave_idx_type& err, double& rcond, 
-		     solve_singularity_handler sing_handler) const
+                     octave_idx_type& err, double& rcond, 
+                     solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7214,7 +7214,7 @@
 
 SparseComplexMatrix
 SparseMatrix::solve (const SparseComplexMatrix& b, 
-		     octave_idx_type& info) const
+                     octave_idx_type& info) const
 {
   double rcond;
   return solve (b, info, rcond, 0);
@@ -7222,15 +7222,15 @@
 
 SparseComplexMatrix
 SparseMatrix::solve (const SparseComplexMatrix& b,
-		     octave_idx_type& info, double& rcond) const
+                     octave_idx_type& info, double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 SparseComplexMatrix
 SparseMatrix::solve (const SparseComplexMatrix& b, 
-		     octave_idx_type& err, double& rcond,
-		     solve_singularity_handler sing_handler) const
+                     octave_idx_type& err, double& rcond,
+                     solve_singularity_handler sing_handler) const
 {
   MatrixType mattype (*this);
   return solve (mattype, b, err, rcond, sing_handler);
@@ -7258,7 +7258,7 @@
 
 ColumnVector
 SparseMatrix::solve (const ColumnVector& b, octave_idx_type& info, double& rcond,
-	       solve_singularity_handler sing_handler) const
+               solve_singularity_handler sing_handler) const
 {
   Matrix tmp (b);
   return solve (tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
@@ -7281,14 +7281,14 @@
 
 ComplexColumnVector
 SparseMatrix::solve (const ComplexColumnVector& b, octave_idx_type& info, 
-		     double& rcond) const
+                     double& rcond) const
 {
   return solve (b, info, rcond, 0);
 }
 
 ComplexColumnVector
 SparseMatrix::solve (const ComplexColumnVector& b, octave_idx_type& info, double& rcond,
-	       solve_singularity_handler sing_handler) const
+               solve_singularity_handler sing_handler) const
 {
   ComplexMatrix tmp (b);
   return solve (tmp, info, rcond, sing_handler).column (static_cast<octave_idx_type> (0));
@@ -7304,14 +7304,14 @@
   if (neg_zero)
     {
       for (octave_idx_type i = 0; i < nel; i++)
-	if (lo_ieee_signbit (data (i)))
-	  return true;
+        if (lo_ieee_signbit (data (i)))
+          return true;
     }
   else
     {
       for (octave_idx_type i = 0; i < nel; i++)
-	if (data (i) < 0)
-	  return true;
+        if (data (i) < 0)
+          return true;
     }
 
   return false;
@@ -7326,7 +7326,7 @@
     {
       double val = data (i);
       if (xisnan (val))
-	return true;
+        return true;
     }
 
   return false;
@@ -7341,7 +7341,7 @@
     {
       double val = data (i);
       if (xisinf (val) || xisnan (val))
-	return true;
+        return true;
     }
 
   return false;
@@ -7356,7 +7356,7 @@
     {
       double val = data (i);
       if (val != 0.0 && val != 1.0)
-	return true;
+        return true;
     }
 
   return false;
@@ -7383,9 +7383,9 @@
     {
       double val = data (i);
       if (xisnan (val) || D_NINT (val) == val)
-	continue;
+        continue;
       else
-	return false;
+        return false;
     }
 
   return true;
@@ -7410,13 +7410,13 @@
       double val = data (i);
 
       if (val > max_val)
-	max_val = val;
+        max_val = val;
 
       if (val < min_val)
-	min_val = val;
+        min_val = val;
 
       if (D_NINT (val) != val)
-	return false;
+        return false;
     }
 
   return true;
@@ -7432,7 +7432,7 @@
       double val = data (i);
 
       if (val > FLT_MAX || val < FLT_MIN)
-	return true;
+        return true;
     }
 
   return false;
@@ -7454,15 +7454,15 @@
   for (octave_idx_type i = 0; i < nc; i++)
     {
       for (octave_idx_type j = 0; j < nr; j++)
-	{
-	  if (jj < cidx(i+1) && ridx(jj) == j)
-	    jj++;
-	  else
-	    {
-	      r.data(ii) = true;
-	      r.ridx(ii++) = j;
-	    }
-	}
+        {
+          if (jj < cidx(i+1) && ridx(jj) == j)
+            jj++;
+          else
+            {
+              r.data(ii) = true;
+              r.ridx(ii++) = j;
+            }
+        }
       r.cidx (i+1) = ii;
     }
 
@@ -7504,7 +7504,7 @@
   else
     {
       SPARSE_REDUCTION_OP (SparseMatrix, double, *=, 
-			   (cidx(j+1) - cidx(j) < nr ? 0.0 : 1.0), 1.0);
+                           (cidx(j+1) - cidx(j) < nr ? 0.0 : 1.0), 1.0);
     }
 }
 
@@ -7526,7 +7526,7 @@
   tmp[j] += d * d
 
   SPARSE_BASE_REDUCTION_OP (SparseMatrix, double, ROW_EXPR, COL_EXPR, 
-			    0.0, 0.0);
+                            0.0, 0.0);
 
 #undef ROW_EXPR
 #undef COL_EXPR
@@ -7575,9 +7575,9 @@
    for (octave_idx_type j = 0; j < nc; j++)  {
       octave_quit ();
       for (octave_idx_type i = a.cidx(j); i < a.cidx(j+1); i++) {
-	os << a.ridx(i) + 1 << " "  << j + 1 << " ";
-	octave_write_double (os, a.data(i));
-	os << "\n";
+        os << a.ridx(i) + 1 << " "  << j + 1 << " ";
+        octave_write_double (os, a.data(i));
+        os << "\n";
       }
    }
 
@@ -7740,43 +7740,43 @@
     {
       result = SparseMatrix (nr, nc, d);
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
-	  {
-	    double tmp = xmin (d, m.data (i));
-	    if (tmp != 0.)
-	      {
-		octave_idx_type idx = m.ridx(i) + j * nr;
-		result.xdata(idx) = tmp;
-		result.xridx(idx) = m.ridx(i);
-	      }
-	  }
+        for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+          {
+            double tmp = xmin (d, m.data (i));
+            if (tmp != 0.)
+              {
+                octave_idx_type idx = m.ridx(i) + j * nr;
+                result.xdata(idx) = tmp;
+                result.xridx(idx) = m.ridx(i);
+              }
+          }
     }
   else
     {
       octave_idx_type nel = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
-	  if (xmin (d, m.data (i)) != 0.)
-	    nel++;
+        for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+          if (xmin (d, m.data (i)) != 0.)
+            nel++;
 
       result = SparseMatrix (nr, nc, nel);
 
       octave_idx_type ii = 0;
       result.xcidx(0) = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
-	    {
-	      double tmp = xmin (d, m.data (i));
-
-	      if (tmp != 0.)
-		{
-		  result.xdata(ii) = tmp;
-		  result.xridx(ii++) = m.ridx(i);
-		}
-	    }
-	  result.xcidx(j+1) = ii;
-	}
+        {
+          for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+            {
+              double tmp = xmin (d, m.data (i));
+
+              if (tmp != 0.)
+                {
+                  result.xdata(ii) = tmp;
+                  result.xridx(ii++) = m.ridx(i);
+                }
+            }
+          result.xcidx(j+1) = ii;
+        }
     }
 
   return result;
@@ -7802,72 +7802,72 @@
       octave_idx_type b_nc = b.cols ();
 
       if (a_nr != b_nr || a_nc != b_nc)
-	gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
+        gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
       else
-	{
-	  r = SparseMatrix (a_nr, a_nc, (a.nnz () + b.nnz ()));
+        {
+          r = SparseMatrix (a_nr, a_nc, (a.nnz () + b.nnz ()));
        
-	  octave_idx_type jx = 0;
-	  r.cidx (0) = 0;
-	  for (octave_idx_type i = 0 ; i < a_nc ; i++)
-	    {
-	      octave_idx_type  ja = a.cidx(i);
-	      octave_idx_type  ja_max = a.cidx(i+1);
-	      bool ja_lt_max= ja < ja_max;
+          octave_idx_type jx = 0;
+          r.cidx (0) = 0;
+          for (octave_idx_type i = 0 ; i < a_nc ; i++)
+            {
+              octave_idx_type  ja = a.cidx(i);
+              octave_idx_type  ja_max = a.cidx(i+1);
+              bool ja_lt_max= ja < ja_max;
            
-	      octave_idx_type  jb = b.cidx(i);
-	      octave_idx_type  jb_max = b.cidx(i+1);
-	      bool jb_lt_max = jb < jb_max;
+              octave_idx_type  jb = b.cidx(i);
+              octave_idx_type  jb_max = b.cidx(i+1);
+              bool jb_lt_max = jb < jb_max;
            
-	      while (ja_lt_max || jb_lt_max )
-		{
-		  octave_quit ();
-		  if ((! jb_lt_max) ||
+              while (ja_lt_max || jb_lt_max )
+                {
+                  octave_quit ();
+                  if ((! jb_lt_max) ||
                       (ja_lt_max && (a.ridx(ja) < b.ridx(jb))))
-		    {
-		      double tmp = xmin (a.data(ja), 0.);
-		      if (tmp != 0.)
-			{
-			  r.ridx(jx) = a.ridx(ja);
-			  r.data(jx) = tmp;
-			  jx++;
-			}
-		      ja++;
-		      ja_lt_max= ja < ja_max;
-		    }
-		  else if (( !ja_lt_max ) ||
-			   (jb_lt_max && (b.ridx(jb) < a.ridx(ja)) ) )
-		    {
-		      double tmp = xmin (0., b.data(jb));
-		      if (tmp != 0.)
-			{
-			  r.ridx(jx) = b.ridx(jb);
-			  r.data(jx) = tmp;
-			  jx++;
-			}
-		      jb++;
-		      jb_lt_max= jb < jb_max;
-		    }
-		  else
-		    {
-		      double tmp = xmin (a.data(ja), b.data(jb));
-		      if (tmp != 0.)
-			{
+                    {
+                      double tmp = xmin (a.data(ja), 0.);
+                      if (tmp != 0.)
+                        {
+                          r.ridx(jx) = a.ridx(ja);
+                          r.data(jx) = tmp;
+                          jx++;
+                        }
+                      ja++;
+                      ja_lt_max= ja < ja_max;
+                    }
+                  else if (( !ja_lt_max ) ||
+                           (jb_lt_max && (b.ridx(jb) < a.ridx(ja)) ) )
+                    {
+                      double tmp = xmin (0., b.data(jb));
+                      if (tmp != 0.)
+                        {
+                          r.ridx(jx) = b.ridx(jb);
+                          r.data(jx) = tmp;
+                          jx++;
+                        }
+                      jb++;
+                      jb_lt_max= jb < jb_max;
+                    }
+                  else
+                    {
+                      double tmp = xmin (a.data(ja), b.data(jb));
+                      if (tmp != 0.)
+                        {
                           r.data(jx) = tmp;
                           r.ridx(jx) = a.ridx(ja);
                           jx++;
-			}
-		      ja++;
-		      ja_lt_max= ja < ja_max;
-		      jb++;
-		      jb_lt_max= jb < jb_max;
-		    }
-		}
-	      r.cidx(i+1) = jx;
-	    }
-	  
-	  r.maybe_compress ();
-	}
+                        }
+                      ja++;
+                      ja_lt_max= ja < ja_max;
+                      jb++;
+                      jb_lt_max= jb < jb_max;
+                    }
+                }
+              r.cidx(i+1) = jx;
+            }
+          
+          r.maybe_compress ();
+        }
     }
   else
     (*current_liboctave_error_handler) ("matrix size mismatch");
@@ -7890,43 +7890,43 @@
     {
       result = SparseMatrix (nr, nc, d);
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
-	  {
-	    double tmp = xmax (d, m.data (i));
-
-	    if (tmp != 0.)
-	      {
-		octave_idx_type idx = m.ridx(i) + j * nr;
-		result.xdata(idx) = tmp;
-		result.xridx(idx) = m.ridx(i);
-	      }
-	  }
+        for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+          {
+            double tmp = xmax (d, m.data (i));
+
+            if (tmp != 0.)
+              {
+                octave_idx_type idx = m.ridx(i) + j * nr;
+                result.xdata(idx) = tmp;
+                result.xridx(idx) = m.ridx(i);
+              }
+          }
     }
   else
     {
       octave_idx_type nel = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
-	  if (xmax (d, m.data (i)) != 0.)
-	    nel++;
+        for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+          if (xmax (d, m.data (i)) != 0.)
+            nel++;
 
       result = SparseMatrix (nr, nc, nel);
 
       octave_idx_type ii = 0;
       result.xcidx(0) = 0;
       for (octave_idx_type j = 0; j < nc; j++)
-	{
-	  for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
-	    {
-	      double tmp = xmax (d, m.data (i));
-	      if (tmp != 0.)
-		{
-		  result.xdata(ii) = tmp;
-		  result.xridx(ii++) = m.ridx(i);
-		}
-	    }
-	  result.xcidx(j+1) = ii;
-	}
+        {
+          for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+            {
+              double tmp = xmax (d, m.data (i));
+              if (tmp != 0.)
+                {
+                  result.xdata(ii) = tmp;
+                  result.xridx(ii++) = m.ridx(i);
+                }
+            }
+          result.xcidx(j+1) = ii;
+        }
     }
 
   return result;
@@ -7952,72 +7952,72 @@
       octave_idx_type b_nc = b.cols ();
 
       if (a_nr != b_nr || a_nc != b_nc)
-	gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
+        gripe_nonconformant ("min", a_nr, a_nc, b_nr, b_nc);
       else
-	{
-	  r = SparseMatrix (a_nr, a_nc, (a.nnz () + b.nnz ()));
+        {
+          r = SparseMatrix (a_nr, a_nc, (a.nnz () + b.nnz ()));
        
-	  octave_idx_type jx = 0;
-	  r.cidx (0) = 0;
-	  for (octave_idx_type i = 0 ; i < a_nc ; i++)
-	    {
-	      octave_idx_type  ja = a.cidx(i);
-	      octave_idx_type  ja_max = a.cidx(i+1);
-	      bool ja_lt_max= ja < ja_max;
+          octave_idx_type jx = 0;
+          r.cidx (0) = 0;
+          for (octave_idx_type i = 0 ; i < a_nc ; i++)
+            {
+              octave_idx_type  ja = a.cidx(i);
+              octave_idx_type  ja_max = a.cidx(i+1);
+              bool ja_lt_max= ja < ja_max;
            
-	      octave_idx_type  jb = b.cidx(i);
-	      octave_idx_type  jb_max = b.cidx(i+1);
-	      bool jb_lt_max = jb < jb_max;
+              octave_idx_type  jb = b.cidx(i);
+              octave_idx_type  jb_max = b.cidx(i+1);
+              bool jb_lt_max = jb < jb_max;
            
-	      while (ja_lt_max || jb_lt_max )
-		{
-		  octave_quit ();
-		  if ((! jb_lt_max) ||
+              while (ja_lt_max || jb_lt_max )
+                {
+                  octave_quit ();
+                  if ((! jb_lt_max) ||
                       (ja_lt_max && (a.ridx(ja) < b.ridx(jb))))
-		    {
-		      double tmp = xmax (a.data(ja), 0.);
-		      if (tmp != 0.)
-			{
-			  r.ridx(jx) = a.ridx(ja);
-			  r.data(jx) = tmp;
-			  jx++;
-			}
-		      ja++;
-		      ja_lt_max= ja < ja_max;
-		    }
-		  else if (( !ja_lt_max ) ||
-			   (jb_lt_max && (b.ridx(jb) < a.ridx(ja)) ) )
-		    {
-		      double tmp = xmax (0., b.data(jb));
-		      if (tmp != 0.)
-			{
-			  r.ridx(jx) = b.ridx(jb);
-			  r.data(jx) = tmp;
-			  jx++;
-			}
-		      jb++;
-		      jb_lt_max= jb < jb_max;
-		    }
-		  else
-		    {
-		      double tmp = xmax (a.data(ja), b.data(jb));
-		      if (tmp != 0.)
-			{
+                    {
+                      double tmp = xmax (a.data(ja), 0.);
+                      if (tmp != 0.)
+                        {
+                          r.ridx(jx) = a.ridx(ja);
+                          r.data(jx) = tmp;
+                          jx++;
+                        }
+                      ja++;
+                      ja_lt_max= ja < ja_max;
+                    }
+                  else if (( !ja_lt_max ) ||
+                           (jb_lt_max && (b.ridx(jb) < a.ridx(ja)) ) )
+                    {
+                      double tmp = xmax (0., b.data(jb));
+                      if (tmp != 0.)
+                        {
+                          r.ridx(jx) = b.ridx(jb);
+                          r.data(jx) = tmp;
+                          jx++;
+                        }
+                      jb++;
+                      jb_lt_max= jb < jb_max;
+                    }
+                  else
+                    {
+                      double tmp = xmax (a.data(ja), b.data(jb));
+                      if (tmp != 0.)
+                        {
                           r.data(jx) = tmp;
                           r.ridx(jx) = a.ridx(ja);
                           jx++;
-			}
-		      ja++;
-		      ja_lt_max= ja < ja_max;
-		      jb++;
-		      jb_lt_max= jb < jb_max;
-		    }
-		}
-	      r.cidx(i+1) = jx;
-	    }
-	  
-	  r.maybe_compress ();
-	}
+                        }
+                      ja++;
+                      ja_lt_max= ja < ja_max;
+                      jb++;
+                      jb_lt_max= jb < jb_max;
+                    }
+                }
+              r.cidx(i+1) = jx;
+            }
+          
+          r.maybe_compress ();
+        }
     }
   else
     (*current_liboctave_error_handler) ("matrix size mismatch");