octave-lyh: liboctave/CSparse.cc comparison

comparison liboctave/CSparse.cc @ 15018:3d8ace26c5b4

maint: Use Octave coding conventions for cuddled parentheses in liboctave/. * Array-util.cc, Array.cc, Array.h, CMatrix.cc, CNDArray.cc, CSparse.cc, CmplxQR.cc, CollocWt.cc, DASPK.cc, DASRT.cc, DASSL.cc, EIG.cc, LSODE.cc, MSparse.cc, MatrixType.cc, Sparse-op-defs.h, Sparse-perm-op-defs.h, Sparse.cc, Sparse.h, SparseCmplxCHOL.cc, SparseCmplxLU.cc, SparseCmplxQR.cc, SparseQR.cc, SparsedbleCHOL.cc, SparsedbleLU.cc, boolSparse.cc, cmd-hist.cc, dDiagMatrix.cc, dMatrix.cc, dNDArray.cc, dSparse.cc, data-conv.cc, dbleQR.cc, dbleSVD.cc, dim-vector.cc, eigs-base.cc, f2c-main.c, fCMatrix.cc, fCNDArray.cc, fCmplxQR.cc, fEIG.cc, fMatrix.cc, fNDArray.cc, floatQR.cc, floatSVD.cc, idx-vector.cc, kpse.cc, lo-specfun.cc, mx-inlines.cc, mx-op-defs.h, oct-alloc.cc, oct-binmap.h, oct-fftw.cc, oct-group.h, oct-inttypes.cc, oct-inttypes.h, oct-locbuf.cc, oct-md5.cc, oct-rand.cc, oct-sort.cc, oct-syscalls.cc, randgamma.c, randmtzig.c, randpoisson.c, sparse-base-chol.cc, sparse-base-lu.cc, sparse-dmsolve.cc, str-vec.cc, str-vec.h, tempnam.c, tempname.c: Use Octave coding conventions for cuddled parentheses in liboctave/.

author	Rik <rik@octave.org>
date	Thu, 26 Jul 2012 08:13:22 -0700
parents	460a3c6d8bf1
children	4bbd3bbb8912

comparison

equal deleted inserted replaced

-:dd4ad69e4ab9
+:3d8ace26c5b4
 ridx (j) = i;
 j++;
 }
 }
 for (octave_idx_type i = l; i <= a.cols (); i++)
-cidx(i) = j;
+cidx (i) = j;
 }
 bool
 SparseComplexMatrix::operator == (const SparseComplexMatrix& a) const
 {
 octave_idx_type nr = rows ();
 if (nr != nr_a || nc != nc_a || nz != nz_a)
 return false;
 for (octave_idx_type i = 0; i < nc + 1; i++)
-if (cidx(i) != a.cidx(i))
+if (cidx (i) != a.cidx (i))
 return false;
 for (octave_idx_type i = 0; i < nz; i++)
-if (data(i) != a.data(i) || ridx(i) != a.ridx(i))
+if (data (i) != a.data (i) || ridx (i) != a.ridx (i))
 return false;
 return true;
 }
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-octave_idx_type ri = ridx(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++)
+for (octave_idx_type k = cidx (ri); k < cidx (ri+1); k++)
 {
-if (ridx(k) == j)
+if (ridx (k) == j)
 {
-if (data(i) == conj(data(k)))
+if (data (i) == conj (data (k)))
 found = true;
 break;
 }
 }
 for (octave_idx_type j = 0; j < nc; j++)
 {
 Complex tmp_max;
 double abs_max = octave_NaN;
 octave_idx_type idx_j = 0;
-for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) != idx_j)
+if (ridx (i) != idx_j)
 break;
 else
 idx_j++;
 }
 {
 tmp_max = 0.;
 abs_max = 0.;
 }
-for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
 Complex tmp = data (i);
 if (xisnan (tmp))
 continue;
 }
 else
 {
 idx_arg.resize (dim_vector (nr, 1), 0);
-for (octave_idx_type i = cidx(0); i < cidx(1); i++)
+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)
+if (idx_arg.elem (i) != -1)
 continue;
 bool found = false;
-for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
+for (octave_idx_type k = cidx (j); k < cidx (j+1); k++)
-if (ridx(k) == i)
+if (ridx (k) == i)
 {
 found = true;
 break;
 }
 if (!found)
-idx_arg.elem(i) = j;
+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++)
+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);
 Complex tmp = data (i);
 if (xisnan (tmp))
 continue;
-else if (ix == -1 || std::abs(tmp) > std::abs(elem (ir, ix)))
+else if (ix == -1 || std::abs (tmp) > std::abs (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.)
+if (idx_arg.elem (j) == -1 || elem (j, idx_arg.elem (j)) != 0.)
 nel++;
 result = SparseComplexMatrix (nr, 1, nel);
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc; j++)
 {
 Complex tmp_min;
 double abs_min = octave_NaN;
 octave_idx_type idx_j = 0;
-for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) != idx_j)
+if (ridx (i) != idx_j)
 break;
 else
 idx_j++;
 }
 {
 tmp_min = 0.;
 abs_min = 0.;
 }
-for (octave_idx_type i = cidx(j); i < cidx(j+1); i++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
 Complex tmp = data (i);
 if (xisnan (tmp))
 continue;
 }
 else
 {
 idx_arg.resize (dim_vector (nr, 1), 0);
-for (octave_idx_type i = cidx(0); i < cidx(1); i++)
+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)
+if (idx_arg.elem (i) != -1)
 continue;
 bool found = false;
-for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
+for (octave_idx_type k = cidx (j); k < cidx (j+1); k++)
-if (ridx(k) == i)
+if (ridx (k) == i)
 {
 found = true;
 break;
 }
 if (!found)
-idx_arg.elem(i) = j;
+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++)
+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);
 Complex tmp = data (i);
 if (xisnan (tmp))
 continue;
-else if (ix == -1 || std::abs(tmp) < std::abs(elem (ir, ix)))
+else if (ix == -1 || std::abs (tmp) < std::abs (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.)
+if (idx_arg.elem (j) == -1 || elem (j, idx_arg.elem (j)) != 0.)
 nel++;
 result = SparseComplexMatrix (nr, 1, nel);
 octave_idx_type ii = 0;
 nz += tmp;
 }
 // retval.xcidx[1:nr] holds row entry *start* offsets for rows 0:(nr-1)
 for (octave_idx_type j = 0; j < nc; j++)
-for (octave_idx_type k = cidx(j); k < cidx(j+1); k++)
+for (octave_idx_type k = cidx (j); k < cidx (j+1); k++)
 {
 octave_idx_type q = retval.xcidx (ridx (k) + 1)++;
 retval.xridx (q) = j;
 retval.xdata (q) = conj (data (k));
 }
 if (calccond)
 {
 double dmax = 0., dmin = octave_Inf;
 for (octave_idx_type i = 0; i < nr; i++)
 {
-double tmp = std::abs(v[i]);
+double tmp = std::abs (v[i]);
 if (tmp > dmax)
 dmax = tmp;
 if (tmp < dmin)
 dmin = tmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 {
 nz2 *= 2;
 retval.change_capacity (nz2);
 }
-retval.xcidx(i) = cx;
+retval.xcidx (i) = cx;
-retval.xridx(cx) = i;
+retval.xridx (cx) = i;
-retval.xdata(cx) = 1.0;
+retval.xdata (cx) = 1.0;
 cx++;
 // iterate accross columns of input matrix
 for (octave_idx_type j = i+1; j < nr; j++)
 {
 Complex v = 0.;
 // iterate to calculate sum
-octave_idx_type colXp = retval.xcidx(i);
+octave_idx_type colXp = retval.xcidx (i);
-octave_idx_type colUp = cidx(j);
+octave_idx_type colUp = cidx (j);
 octave_idx_type rpX, rpU;
-if (cidx(j) == cidx(j+1))
+if (cidx (j) == cidx (j+1))
 {
 (*current_liboctave_error_handler)
 ("division by zero");
 goto inverse_singular;
 }
 do
 {
 octave_quit ();
-rpX = retval.xridx(colXp);
+rpX = retval.xridx (colXp);
-rpU = ridx(colUp);
+rpU = ridx (colUp);
 if (rpX < rpU)
 colXp++;
 else if (rpX > rpU)
 colUp++;
 else
 {
-v -= retval.xdata(colXp) * data(colUp);
+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;
+colUp = cidx (j+1) - 1;
 else
-colUp = cidx(j);
+colUp = cidx (j);
-Complex pivot = data(colUp);
+Complex pivot = data (colUp);
-if (pivot == 0. || ridx(colUp) != j)
+if (pivot == 0. || ridx (colUp) != j)
 {
 (*current_liboctave_error_handler)
 ("division by zero");
 goto inverse_singular;
 }
 {
 nz2 *= 2;
 retval.change_capacity (nz2);
 }
-retval.xridx(cx) = j;
+retval.xridx (cx) = j;
-retval.xdata(cx) = v / pivot;
+retval.xdata (cx) = v / pivot;
 cx++;
 }
 }
 // get A(m,m)
 octave_idx_type colUp;
 if (typ == MatrixType::Upper)
-colUp = cidx(i+1) - 1;
+colUp = cidx (i+1) - 1;
 else
-colUp = cidx(i);
+colUp = cidx (i);
-Complex pivot = data(colUp);
+Complex pivot = data (colUp);
-if (pivot == 0. || ridx(colUp) != i)
+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.xdata (j) /= pivot;
 }
-retval.xcidx(nr) = cx;
+retval.xcidx (nr) = cx;
 retval.maybe_compress ();
 }
 else
 {
 octave_idx_type nz = nnz ();
 for (octave_idx_type j = iidx+1; j < nr; j++)
 {
 Complex v = 0.;
 octave_idx_type jidx = perm[j];
 // iterate to calculate sum
-for (octave_idx_type k = cidx(jidx);
+for (octave_idx_type k = cidx (jidx);
-k < cidx(jidx+1); k++)
+k < cidx (jidx+1); k++)
 {
 octave_quit ();
-v -= work[ridx(k)] * data(k);
+v -= work[ridx (k)] * data (k);
 }
 // get A(m,m)
 Complex pivot;
 if (typ == MatrixType::Permuted_Upper)
-pivot = data(cidx(jidx+1) - 1);
+pivot = data (cidx (jidx+1) - 1);
 else
-pivot = data(cidx(jidx));
+pivot = data (cidx (jidx));
 if (pivot == 0.)
 {
 (*current_liboctave_error_handler)
 ("division by zero");
 goto inverse_singular;
 }
 // get A(m,m)
 octave_idx_type colUp;
 if (typ == MatrixType::Permuted_Upper)
-colUp = cidx(perm[iidx]+1) - 1;
+colUp = cidx (perm[iidx]+1) - 1;
 else
-colUp = cidx(perm[iidx]);
+colUp = cidx (perm[iidx]);
-Complex pivot = data(colUp);
+Complex pivot = data (colUp);
 if (pivot == 0.)
 {
 (*current_liboctave_error_handler)
 ("division by zero");
 goto inverse_singular;
 {
 nz2 = (2*nz2 < new_cx ? new_cx : 2*nz2);
 retval.change_capacity (nz2);
 }
-retval.xcidx(i) = cx;
+retval.xcidx (i) = cx;
 for (octave_idx_type j = iidx; j < nr; j++)
 if (work[j] != 0.)
 {
-retval.xridx(cx) = j;
+retval.xridx (cx) = j;
-retval.xdata(cx++) = work[j];
+retval.xdata (cx++) = work[j];
 }
 }
-retval.xcidx(nr) = cx;
+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);
+for (octave_idx_type i = retval.cidx (j);
-i < retval.cidx(j+1); i++)
+i < retval.cidx (j+1); i++)
-atmp += std::abs(retval.data(i));
+atmp += std::abs (retval.data (i));
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 rcond = 1. / ainvnorm / anorm;
 if (info == 0)
 {
 double rcond2;
 SparseMatrix Q = fact.Q ();
 SparseComplexMatrix InvL = fact.L ().transpose ().
-tinverse(tmp_typ, info, rcond2, true, false);
+tinverse (tmp_typ, info, rcond2, true, false);
 ret = Q * InvL.hermitian () * InvL * Q.transpose ();
 }
 else
 {
 // Matrix is either singular or not positive definite
 MatrixType tmp_typ (MatrixType::Upper);
 SparseComplexLU fact (*this, Qinit, Matrix (), false, false);
 rcond = fact.rcond ();
 double rcond2;
 SparseComplexMatrix InvL = fact.L ().transpose ().
-tinverse(tmp_typ, info, rcond2, true, false);
+tinverse (tmp_typ, info, rcond2, true, false);
 SparseComplexMatrix InvU = fact.U ().
-tinverse(tmp_typ, info, rcond2, true, false).transpose ();
+tinverse (tmp_typ, info, rcond2, true, false).transpose ();
 ret = fact.Pc ().transpose () * InvU * InvL * fact.Pr ();
 }
 }
 return ret;
 mattype.info ();
 if (typ == MatrixType::Diagonal ||
 typ == MatrixType::Permuted_Diagonal)
 {
-retval.resize (nc, b.cols (), Complex(0.,0.));
+retval.resize (nc, b.cols (), Complex (0.,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++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
-retval(k,j) = b(ridx(i),j) / data (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 = std::abs(data(i));
+double tmp = std::abs (data (i));
 if (tmp > dmax)
 dmax = tmp;
 if (tmp < dmin)
 dmin = tmp;
 }
 {
 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;
+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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
 {
-if (b.ridx(i) >= nm)
+if (b.ridx (i) >= nm)
 break;
-retval.xridx (ii) = b.ridx(i);
+retval.xridx (ii) = b.ridx (i);
-retval.xdata (ii++) = b.data(i) / data (b.ridx (i));
+retval.xdata (ii++) = b.data (i) / data (b.ridx (i));
 }
-retval.xcidx(j+1) = ii;
+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++)
+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++)
+for (k = b.cidx (j); k < b.cidx (j+1); k++)
-if (ridx(i) == b.ridx(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.xdata (ii++) = b.data (k) / data (i);
 }
 }
-retval.xcidx(j+1) = ii;
+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 = std::abs(data(i));
+double tmp = std::abs (data (i));
 if (tmp > dmax)
 dmax = tmp;
 if (tmp < dmin)
 dmin = tmp;
 }
 mattype.info ();
 if (typ == MatrixType::Diagonal ||
 typ == MatrixType::Permuted_Diagonal)
 {
-retval.resize (nc, b.cols (), Complex(0.,0.));
+retval.resize (nc, b.cols (), Complex (0.,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++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
-retval(k,j) = b(ridx(i),j) / data (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 < nr; i++)
 {
-double tmp = std::abs(data(i));
+double tmp = std::abs (data (i));
 if (tmp > dmax)
 dmax = tmp;
 if (tmp < dmin)
 dmin = tmp;
 }
 {
 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;
+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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
 {
-if (b.ridx(i) >= nm)
+if (b.ridx (i) >= nm)
 break;
-retval.xridx (ii) = b.ridx(i);
+retval.xridx (ii) = b.ridx (i);
-retval.xdata (ii++) = b.data(i) / data (b.ridx (i));
+retval.xdata (ii++) = b.data (i) / data (b.ridx (i));
 }
-retval.xcidx(j+1) = ii;
+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++)
+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++)
+for (k = b.cidx (j); k < b.cidx (j+1); k++)
-if (ridx(i) == b.ridx(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.xdata (ii++) = b.data (k) / data (i);
 }
 }
-retval.xcidx(j+1) = ii;
+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 = std::abs(data(i));
+double tmp = std::abs (data (i));
 if (tmp > dmax)
 dmax = tmp;
 if (tmp < dmin)
 dmin = tmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 {
 octave_idx_type kidx = perm[k];
 if (work[k] != 0.)
 {
-if (ridx(cidx(kidx+1)-1) != k ||
+if (ridx (cidx (kidx+1)-1) != k ||
-data(cidx(kidx+1)-1) == 0.)
+data (cidx (kidx+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(kidx+1)-1);
+Complex tmp = work[k] / data (cidx (kidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(kidx);
+for (octave_idx_type i = cidx (kidx);
-i < cidx(kidx+1)-1; i++)
+i < cidx (kidx+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 {
 octave_idx_type iidx = perm[k];
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(iidx+1)-1);
+Complex tmp = work[k] / data (cidx (iidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(iidx);
+for (octave_idx_type i = cidx (iidx);
-i < cidx(iidx+1)-1; i++)
+i < cidx (iidx+1)-1; i++)
 {
-octave_idx_type idx2 = ridx(i);
+octave_idx_type idx2 = ridx (i);
-work[idx2] = work[idx2] - tmp * data(i);
+work[idx2] = work[idx2] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 for (octave_idx_type k = nc-1; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-if (ridx(cidx(k+1)-1) != k ||
+if (ridx (cidx (k+1)-1) != k ||
-data(cidx(k+1)-1) == 0.)
+data (cidx (k+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 for (octave_idx_type k = j; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1)-1; i++)
+i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (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;
+retval.xcidx (0) = 0;
 octave_idx_type ii = 0;
 octave_idx_type x_nz = b_nz;
 if (typ == MatrixType::Permuted_Upper)
 {
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(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 ||
+if (ridx (cidx (kidx+1)-1) != k ||
-data(cidx(kidx+1)-1) == 0.)
+data (cidx (kidx+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(kidx+1)-1);
+Complex tmp = work[k] / data (cidx (kidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(kidx);
+for (octave_idx_type i = cidx (kidx);
-i < cidx(kidx+1)-1; i++)
+i < cidx (kidx+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[rperm[i]] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[rperm[i]];
+retval.xdata (ii++) = work[rperm[i]];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 {
 octave_idx_type iidx = perm[k];
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(iidx+1)-1);
+Complex tmp = work[k] / data (cidx (iidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(iidx);
+for (octave_idx_type i = cidx (iidx);
-i < cidx(iidx+1)-1; i++)
+i < cidx (iidx+1)-1; i++)
 {
-octave_idx_type idx2 = ridx(i);
+octave_idx_type idx2 = ridx (i);
-work[idx2] = work[idx2] - tmp * data(i);
+work[idx2] = work[idx2] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(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 ||
+if (ridx (cidx (k+1)-1) != k ||
-data(cidx(k+1)-1) == 0.)
+data (cidx (k+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 for (octave_idx_type k = j; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1)-1; i++)
+i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 {
 octave_idx_type kidx = perm[k];
 if (work[k] != 0.)
 {
-if (ridx(cidx(kidx+1)-1) != k ||
+if (ridx (cidx (kidx+1)-1) != k ||
-data(cidx(kidx+1)-1) == 0.)
+data (cidx (kidx+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(kidx+1)-1);
+Complex tmp = work[k] / data (cidx (kidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(kidx);
+for (octave_idx_type i = cidx (kidx);
-i < cidx(kidx+1)-1; i++)
+i < cidx (kidx+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 {
 octave_idx_type iidx = perm[k];
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(iidx+1)-1);
+Complex tmp = work[k] / data (cidx (iidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(iidx);
+for (octave_idx_type i = cidx (iidx);
-i < cidx(iidx+1)-1; i++)
+i < cidx (iidx+1)-1; i++)
 {
-octave_idx_type idx2 = ridx(i);
+octave_idx_type idx2 = ridx (i);
-work[idx2] = work[idx2] - tmp * data(i);
+work[idx2] = work[idx2] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 for (octave_idx_type k = nc-1; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-if (ridx(cidx(k+1)-1) != k ||
+if (ridx (cidx (k+1)-1) != k ||
-data(cidx(k+1)-1) == 0.)
+data (cidx (k+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 for (octave_idx_type k = j; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1)-1; i++)
+i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (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;
+retval.xcidx (0) = 0;
 octave_idx_type ii = 0;
 octave_idx_type x_nz = b_nz;
 if (typ == MatrixType::Permuted_Upper)
 {
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(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 ||
+if (ridx (cidx (kidx+1)-1) != k ||
-data(cidx(kidx+1)-1) == 0.)
+data (cidx (kidx+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(kidx+1)-1);
+Complex tmp = work[k] / data (cidx (kidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(kidx);
+for (octave_idx_type i = cidx (kidx);
-i < cidx(kidx+1)-1; i++)
+i < cidx (kidx+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[rperm[i]] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[rperm[i]];
+retval.xdata (ii++) = work[rperm[i]];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 {
 octave_idx_type iidx = perm[k];
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(iidx+1)-1);
+Complex tmp = work[k] / data (cidx (iidx+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(iidx);
+for (octave_idx_type i = cidx (iidx);
-i < cidx(iidx+1)-1; i++)
+i < cidx (iidx+1)-1; i++)
 {
-octave_idx_type idx2 = ridx(i);
+octave_idx_type idx2 = ridx (i);
-work[idx2] = work[idx2] - tmp * data(i);
+work[idx2] = work[idx2] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(i);
+work[b.ridx (i)] = b.data (i);
 for (octave_idx_type k = nr-1; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-if (ridx(cidx(k+1)-1) != k ||
+if (ridx (cidx (k+1)-1) != k ||
-data(cidx(k+1)-1) == 0.)
+data (cidx (k+1)-1) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1)-1; i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 for (octave_idx_type k = j; k >= 0; k--)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k+1)-1);
+Complex tmp = work[k] / data (cidx (k+1)-1);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1)-1; i++)
+i < cidx (k+1)-1; i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = 0; i < j+1; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 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++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
 if (minr != k || data (mini) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[k] != 0.)
 {
 octave_idx_type minr = nr;
 octave_idx_type mini = 0;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 work[i] = 0.;
 for (octave_idx_type k = 0; k < nc; k++)
 {
 if (work[k] != 0.)
 {
-if (ridx(cidx(k)) != k ||
+if (ridx (cidx (k)) != k ||
-data(cidx(k)) == 0.)
+data (cidx (k)) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k)+1; i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 retval.xelem (i, j) = work[i];
 for (octave_idx_type k = j; k < nc; k++)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1;
+for (octave_idx_type i = cidx (k)+1;
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (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;
+retval.xcidx (0) = 0;
 octave_idx_type ii = 0;
 octave_idx_type x_nz = b_nz;
 if (typ == MatrixType::Permuted_Lower)
 {
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[perm[b.ridx(i)]] = b.data(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++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
 if (minr != k || data (mini) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 if (work[k] != 0.)
 {
 octave_idx_type minr = nr;
 octave_idx_type mini = 0;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(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 ||
+if (ridx (cidx (k)) != k ||
-data(cidx(k)) == 0.)
+data (cidx (k)) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k)+1; i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 for (octave_idx_type k = j; k < nc; k++)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1;
+for (octave_idx_type i = cidx (k)+1;
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 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++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
 if (minr != k || data (mini) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[k] != 0.)
 {
 octave_idx_type minr = nr;
 octave_idx_type mini = 0;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 for (octave_idx_type k = 0; k < nc; k++)
 {
 if (work[k] != 0.)
 {
-if (ridx(cidx(k)) != k ||
+if (ridx (cidx (k)) != k ||
-data(cidx(k)) == 0.)
+data (cidx (k)) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k)+1; i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 for (octave_idx_type i = 0; i < nc; i++)
 for (octave_idx_type k = j; k < nc; k++)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1;
+for (octave_idx_type i = cidx (k)+1;
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 // 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (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;
+retval.xcidx (0) = 0;
 octave_idx_type ii = 0;
 octave_idx_type x_nz = b_nz;
 if (typ == MatrixType::Permuted_Lower)
 {
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[perm[b.ridx(i)]] = b.data(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++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
 if (minr != k || data (mini) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k); i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k); i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 if (work[k] != 0.)
 {
 octave_idx_type minr = nr;
 octave_idx_type mini = 0;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
-if (perm[ridx(i)] < minr)
+if (perm[ridx (i)] < minr)
 {
-minr = perm[ridx(i)];
+minr = perm[ridx (i)];
 mini = i;
 }
-Complex tmp = work[k] / data(mini);
+Complex tmp = work[k] / data (mini);
 work[k] = tmp;
-for (octave_idx_type i = cidx(k);
+for (octave_idx_type i = cidx (k);
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
 if (i == mini)
 continue;
-octave_idx_type iidx = perm[ridx(i)];
+octave_idx_type iidx = perm[ridx (i)];
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(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 ||
+if (ridx (cidx (k)) != k ||
-data(cidx(k)) == 0.)
+data (cidx (k)) == 0.)
 {
 err = -2;
 goto triangular_error;
 }
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1; i < cidx(k+1); i++)
+for (octave_idx_type i = cidx (k)+1; i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 // Count non-zeros in work vector and adjust space in
 }
 for (octave_idx_type i = 0; i < nc; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 if (calc_cond)
 for (octave_idx_type k = j; k < nc; k++)
 {
 if (work[k] != 0.)
 {
-Complex tmp = work[k] / data(cidx(k));
+Complex tmp = work[k] / data (cidx (k));
 work[k] = tmp;
-for (octave_idx_type i = cidx(k)+1;
+for (octave_idx_type i = cidx (k)+1;
-i < cidx(k+1); i++)
+i < cidx (k+1); i++)
 {
-octave_idx_type iidx = ridx(i);
+octave_idx_type iidx = ridx (i);
-work[iidx] = work[iidx] - tmp * data(i);
+work[iidx] = work[iidx] - tmp * data (i);
 }
 }
 }
 double atmp = 0;
 for (octave_idx_type i = j; i < nc; i++)
 {
-atmp += std::abs(work[i]);
+atmp += std::abs (work[i]);
 work[i] = 0.;
 }
 if (atmp > ainvnorm)
 ainvnorm = atmp;
 }
 {
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc-1; j++)
 {
-D[j] = std::real(data(ii++));
+D[j] = std::real (data (ii++));
-DL[j] = data(ii);
+DL[j] = data (ii);
 ii += 2;
 }
-D[nc-1] = std::real(data(ii));
+D[nc-1] = std::real (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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) == j)
+if (ridx (i) == j)
-D[j] = std::real(data(i));
+D[j] = std::real (data (i));
-else if (ridx(i) == j + 1)
+else if (ridx (i) == j + 1)
-DL[j] = data(i);
+DL[j] = data (i);
 }
 }
 octave_idx_type b_nc = b.cols ();
 retval = ComplexMatrix (b);
 {
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc-1; j++)
 {
-D[j] = data(ii++);
+D[j] = data (ii++);
-DL[j] = data(ii++);
+DL[j] = data (ii++);
-DU[j] = data(ii++);
+DU[j] = data (ii++);
 }
-D[nc-1] = data(ii);
+D[nc-1] = data (ii);
 }
 else
 {
 D[0] = 0.;
 for (octave_idx_type i = 0; i < nr - 1; i++)
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) == j)
+if (ridx (i) == j)
-D[j] = data(i);
+D[j] = data (i);
-else if (ridx(i) == j + 1)
+else if (ridx (i) == j + 1)
-DL[j] = data(i);
+DL[j] = data (i);
-else if (ridx(i) == j - 1)
+else if (ridx (i) == j - 1)
-DU[j-1] = data(i);
+DU[j-1] = data (i);
 }
 }
 octave_idx_type b_nc = b.cols ();
 retval = ComplexMatrix (b);
 {
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc-1; j++)
 {
-D[j] = data(ii++);
+D[j] = data (ii++);
-DL[j] = data(ii++);
+DL[j] = data (ii++);
-DU[j] = data(ii++);
+DU[j] = data (ii++);
 }
-D[nc-1] = data(ii);
+D[nc-1] = data (ii);
 }
 else
 {
 D[0] = 0.;
 for (octave_idx_type i = 0; i < nr - 1; i++)
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) == j)
+if (ridx (i) == j)
-D[j] = data(i);
+D[j] = data (i);
-else if (ridx(i) == j + 1)
+else if (ridx (i) == j + 1)
-DL[j] = data(i);
+DL[j] = data (i);
-else if (ridx(i) == j - 1)
+else if (ridx (i) == j - 1)
-DU[j-1] = data(i);
+DU[j-1] = data (i);
 }
 }
 F77_XFCN (zgttrf, ZGTTRF, (nr, DL, D, DU, DU2, pipvt, err));
 {
 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;
+retval.xcidx (0) = 0;
 volatile octave_idx_type ii = 0;
 rcond = 1.0;
 OCTAVE_LOCAL_BUFFER (Complex, 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++)
+for (octave_idx_type i = b.cidx (j); i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(i);
+work[b.ridx (i)] = b.data (i);
 F77_XFCN (zgttrs, ZGTTRS,
 (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, 1, DL, D, DU, DU2, pipvt,
 work, b.rows (), err
 }
 for (octave_idx_type i = 0; i < nr; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 }
 }
 {
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc-1; j++)
 {
-D[j] = std::real(data(ii++));
+D[j] = std::real (data (ii++));
-DL[j] = data(ii);
+DL[j] = data (ii);
 ii += 2;
 }
-D[nc-1] = std::real(data(ii));
+D[nc-1] = std::real (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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) == j)
+if (ridx (i) == j)
-D[j] = std::real (data(i));
+D[j] = std::real (data (i));
-else if (ridx(i) == j + 1)
+else if (ridx (i) == j + 1)
-DL[j] = data(i);
+DL[j] = data (i);
 }
 }
 octave_idx_type b_nr = b.rows ();
 octave_idx_type b_nc = b.cols ();
 {
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc-1; j++)
 {
-D[j] = data(ii++);
+D[j] = data (ii++);
-DL[j] = data(ii++);
+DL[j] = data (ii++);
-DU[j] = data(ii++);
+DU[j] = data (ii++);
 }
-D[nc-1] = data(ii);
+D[nc-1] = data (ii);
 }
 else
 {
 D[0] = 0.;
 for (octave_idx_type i = 0; i < nr - 1; i++)
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) == j)
+if (ridx (i) == j)
-D[j] = data(i);
+D[j] = data (i);
-else if (ridx(i) == j + 1)
+else if (ridx (i) == j + 1)
-DL[j] = data(i);
+DL[j] = data (i);
-else if (ridx(i) == j - 1)
+else if (ridx (i) == j - 1)
-DU[j-1] = data(i);
+DU[j-1] = data (i);
 }
 }
 octave_idx_type b_nr = b.rows ();
 octave_idx_type b_nc = b.cols ();
 {
 octave_idx_type ii = 0;
 for (octave_idx_type j = 0; j < nc-1; j++)
 {
-D[j] = data(ii++);
+D[j] = data (ii++);
-DL[j] = data(ii++);
+DL[j] = data (ii++);
-DU[j] = data(ii++);
+DU[j] = data (ii++);
 }
-D[nc-1] = data(ii);
+D[nc-1] = data (ii);
 }
 else
 {
 D[0] = 0.;
 for (octave_idx_type i = 0; i < nr - 1; i++)
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
 {
-if (ridx(i) == j)
+if (ridx (i) == j)
-D[j] = data(i);
+D[j] = data (i);
-else if (ridx(i) == j + 1)
+else if (ridx (i) == j + 1)
-DL[j] = data(i);
+DL[j] = data (i);
-else if (ridx(i) == j - 1)
+else if (ridx (i) == j - 1)
-DU[j-1] = data(i);
+DU[j-1] = data (i);
 }
 }
 F77_XFCN (zgttrf, ZGTTRF, (nr, DL, D, DU, DU2, pipvt, err));
 // 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;
+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 (i,j);
 }
 for (octave_idx_type i = 0; i < nr; i++)
 if (Bx[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = Bx[i];
+retval.xdata (ii++) = Bx[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 }
 }
 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++)
+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);
+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 ();
+anorm = m_band.abs ().sum ().row (0).max ();
 char job = 'L';
 F77_XFCN (zpbtrf, ZPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, n_lower, tmp_data, ldm, err
 F77_CHAR_ARG_LEN (1)));
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-m_band(ridx(i) - j + n_lower + n_upper, j) = data(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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 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++)
+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);
+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 ();
+anorm = m_band.abs ().sum ().row (0).max ();
 char job = 'L';
 F77_XFCN (zpbtrf, ZPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, n_lower, tmp_data, ldm, err
 F77_CHAR_ARG_LEN (1)));
 // 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;
+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);
 (b_nc - j) / b_nc;
 sz = (sz > 10 ? sz : 10) + x_nz;
 retval.change_capacity (sz);
 x_nz = sz;
 }
-retval.xdata(ii) = tmp;
+retval.xdata (ii) = tmp;
-retval.xridx(ii++) = i;
+retval.xridx (ii++) = i;
 }
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 }
 }
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-m_band(ridx(i) - j + n_lower + n_upper, j) = data(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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 {
 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;
+retval.xcidx (0) = 0;
 volatile octave_idx_type ii = 0;
 OCTAVE_LOCAL_BUFFER (Complex, 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);
+for (octave_idx_type i = b.cidx (j);
-i < b.cidx(j+1); i++)
+i < b.cidx (j+1); i++)
-work[b.ridx(i)] = b.data(i);
+work[b.ridx (i)] = b.data (i);
 F77_XFCN (zgbtrs, ZGBTRS,
 (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, n_lower, n_upper, 1, tmp_data,
 ldm, pipvt, work, b.rows (), err
 }
 for (octave_idx_type i = 0; i < nr; i++)
 if (work[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = work[i];
+retval.xdata (ii++) = work[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 }
 }
 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++)
+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);
+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 ();
+anorm = m_band.abs ().sum ().row (0).max ();
 char job = 'L';
 F77_XFCN (zpbtrf, ZPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, n_lower, tmp_data, ldm, err
 F77_CHAR_ARG_LEN (1)));
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-m_band(ridx(i) - j + n_lower + n_upper, j) = data(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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 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++)
+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);
+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 ();
+anorm = m_band.abs ().sum ().row (0).max ();
 char job = 'L';
 F77_XFCN (zpbtrf, ZPBTRF, (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, n_lower, tmp_data, ldm, err
 F77_CHAR_ARG_LEN (1)));
 // 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;
+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 (i,j);
 }
 for (octave_idx_type i = 0; i < nr; i++)
 if (Bx[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = Bx[i];
+retval.xdata (ii++) = Bx[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 }
 }
 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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-m_band(ridx(i) - j + n_lower + n_upper, j) = data(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++)
+for (octave_idx_type i = cidx (j); i < cidx (j+1); i++)
-atmp += std::abs(data(i));
+atmp += std::abs (data (i));
 if (atmp > anorm)
 anorm = atmp;
 }
 }
 {
 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;
+retval.xcidx (0) = 0;
 volatile octave_idx_type ii = 0;
 OCTAVE_LOCAL_BUFFER (Complex, Bx, nr);
 for (volatile octave_idx_type j = 0; j < b_nc; j++)
 {
 for (octave_idx_type i = 0; i < nr; i++)
 Bx[i] = 0.;
-for (octave_idx_type i = b.cidx(j);
+for (octave_idx_type i = b.cidx (j);
-i < b.cidx(j+1); i++)
+i < b.cidx (j+1); i++)
-Bx[b.ridx(i)] = b.data(i);
+Bx[b.ridx (i)] = b.data (i);
 F77_XFCN (zgbtrs, ZGBTRS,
 (F77_CONST_CHAR_ARG2 (&job, 1),
 nr, n_lower, n_upper, 1, tmp_data,
 ldm, pipvt, Bx, b.rows (), err
 }
 for (octave_idx_type i = 0; i < nr; i++)
 if (Bx[i] != 0.)
 {
-retval.xridx(ii) = i;
+retval.xridx (ii) = i;
-retval.xdata(ii++) = Bx[i];
+retval.xdata (ii++) = Bx[i];
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 }
 }
 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];
+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);
 (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];
+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.xridx (j) = static_cast<octave_idx_type *>(X->i)[j];
-retval.xdata(j) = static_cast<Complex *>(X->x)[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);
 octave_idx_type ii = 0;
 retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
 OCTAVE_LOCAL_BUFFER (Complex, Xx, b_nr);
-retval.xcidx(0) = 0;
+retval.xcidx (0) = 0;
 for (octave_idx_type j = 0; j < b_nc; j++)
 {
 #ifdef UMFPACK_SEPARATE_SPLIT
 for (octave_idx_type i = 0; i < b_nr; i++)
 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.xdata (ii) = tmp;
-retval.xridx(ii++) = i;
+retval.xridx (ii++) = i;
 }
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 UMFPACK_ZNAME (report_info) (control, info);
 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];
+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);
 (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];
+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.xridx (j) = static_cast<octave_idx_type *>(X->i)[j];
-retval.xdata(j) = static_cast<Complex *>(X->x)[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);
 octave_idx_type ii = 0;
 retval = SparseComplexMatrix (b_nr, b_nc, x_nz);
 OCTAVE_LOCAL_BUFFER (Complex, Xx, b_nr);
-retval.xcidx(0) = 0;
+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 (i,j);
 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.xdata (ii) = tmp;
-retval.xridx(ii++) = i;
+retval.xridx (ii++) = i;
 }
 }
-retval.xcidx(j+1) = ii;
+retval.xcidx (j+1) = ii;
 }
 retval.maybe_compress ();
 rcond = Info (UMFPACK_RCOND);
 {
 (*current_liboctave_error_handler) ("unknown matrix type");
 return ComplexMatrix ();
 }
-if (singular_fallback && mattype.type(false) == MatrixType::Rectangular)
+if (singular_fallback && mattype.type (false) == MatrixType::Rectangular)
 {
 rcond = 1.;
 #ifdef USE_QRSOLVE
 retval = qrsolve (*this, b, err);
 #else
 {
 (*current_liboctave_error_handler) ("unknown matrix type");
 return SparseComplexMatrix ();
 }
-if (singular_fallback && mattype.type(false) == MatrixType::Rectangular)
+if (singular_fallback && mattype.type (false) == MatrixType::Rectangular)
 {
 rcond = 1.;
 #ifdef USE_QRSOLVE
 retval = qrsolve (*this, b, err);
 #else
 {
 (*current_liboctave_error_handler) ("unknown matrix type");
 return ComplexMatrix ();
 }
-if (singular_fallback && mattype.type(false) == MatrixType::Rectangular)
+if (singular_fallback && mattype.type (false) == MatrixType::Rectangular)
 {
 rcond = 1.;
 #ifdef USE_QRSOLVE
 retval = qrsolve (*this, b, err);
 #else
 {
 (*current_liboctave_error_handler) ("unknown matrix type");
 return SparseComplexMatrix ();
 }
-if (singular_fallback && mattype.type(false) == MatrixType::Rectangular)
+if (singular_fallback && mattype.type (false) == MatrixType::Rectangular)
 {
 rcond = 1.;
 #ifdef USE_QRSOLVE
 retval = qrsolve (*this, b, err);
 #else
 r.cidx (0) = 0;
 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)
+if (jj < cidx (i+1) && ridx (jj) == j)
 jj++;
 else
 {
-r.data(ii) = true;
+r.data (ii) = true;
-r.ridx(ii++) = j;
+r.ridx (ii++) = j;
 }
 }
 r.cidx (i+1) = ii;
 }
 octave_idx_type nel = nnz ();
 if (nel == 0)
 return false;
-max_val = std::real(data (0));
+max_val = std::real (data (0));
-min_val = std::real(data (0));
+min_val = std::real (data (0));
 for (octave_idx_type i = 0; i < nel; i++)
 {
 Complex val = data (i);
 if ((rows () == 1 && dim == -1) || dim == 1)
 return transpose (). prod (0). transpose ();
 else
 {
 SPARSE_REDUCTION_OP (SparseComplexMatrix, Complex, *=,
-(cidx(j+1) - cidx(j) < nr ? 0.0 : 1.0), 1.0);
+(cidx (j+1) - cidx (j) < nr ? 0.0 : 1.0), 1.0);
 }
 }
 SparseComplexMatrix
 SparseComplexMatrix::sum (int dim) const
 SparseComplexMatrix
 SparseComplexMatrix::sumsq (int dim) const
 {
 #define ROW_EXPR \
 Complex d = data (i); \
-tmp [ridx(i)] += d * conj (d)
+tmp[ridx (i)] += d * conj (d)
 #define COL_EXPR \
 Complex d = data (i); \
-tmp [j] += d * conj (d)
+tmp[j] += d * conj (d)
 SPARSE_BASE_REDUCTION_OP (SparseComplexMatrix, Complex, ROW_EXPR,
 COL_EXPR, 0.0, 0.0);
 #undef ROW_EXPR
 // add one to the printed indices to go from
 //  zero-based to one-based arrays
 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++)
+for (octave_idx_type i = a.cidx (j); i < a.cidx (j+1); i++)
 {
-os << a.ridx(i) + 1 << " "  << j + 1 << " ";
+os << a.ridx (i) + 1 << " "  << j + 1 << " ";
-octave_write_complex (os, a.data(i));
+octave_write_complex (os, a.data (i));
 os << "\n";
 }
 }
 return os;
 octave_idx_type nr = m.rows ();
 octave_idx_type nc = m.columns ();
 EMPTY_RETURN_CHECK (SparseComplexMatrix);
-if (abs(c) == 0.)
+if (abs (c) == 0.)
 return SparseComplexMatrix (nr, nc);
 else
 {
 result = SparseComplexMatrix (m);
 for (octave_idx_type j = 0; j < nc; j++)
-for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++)
-result.data(i) = xmin(c, m.data(i));
+result.data (i) = xmin (c, m.data (i));
 }
 return result;
 }
 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 = a.cidx (i);
-octave_idx_type  ja_max = a.cidx(i+1);
+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 = b.cidx (i);
-octave_idx_type  jb_max = b.cidx(i+1);
+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) ||
-(ja_lt_max && (a.ridx(ja) < b.ridx(jb))))
+(ja_lt_max && (a.ridx (ja) < b.ridx (jb))))
 {
-Complex tmp = xmin (a.data(ja), 0.);
+Complex tmp = xmin (a.data (ja), 0.);
 if (tmp != 0.)
 {
-r.ridx(jx) = a.ridx(ja);
+r.ridx (jx) = a.ridx (ja);
-r.data(jx) = tmp;
+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)) ) )
+(jb_lt_max && (b.ridx (jb) < a.ridx (ja)) ) )
 {
-Complex tmp = xmin (0., b.data(jb));
+Complex tmp = xmin (0., b.data (jb));
 if (tmp != 0.)
 {
-r.ridx(jx) = b.ridx(jb);
+r.ridx (jx) = b.ridx (jb);
-r.data(jx) = tmp;
+r.data (jx) = tmp;
 jx++;
 }
 jb++;
 jb_lt_max= jb < jb_max;
 }
 else
 {
-Complex tmp = xmin (a.data(ja), b.data(jb));
+Complex tmp = xmin (a.data (ja), b.data (jb));
 if (tmp != 0.)
 {
-r.data(jx) = tmp;
+r.data (jx) = tmp;
-r.ridx(jx) = a.ridx(ja);
+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.cidx (i+1) = jx;
 }
 r.maybe_compress ();
 }
 }
 octave_idx_type nc = m.columns ();
 EMPTY_RETURN_CHECK (SparseComplexMatrix);
 // Count the number of non-zero elements
-if (xmax(c, 0.) != 0.)
+if (xmax (c, 0.) != 0.)
 {
 result = SparseComplexMatrix (nr, nc, c);
 for (octave_idx_type j = 0; j < nc; j++)
-for (octave_idx_type i = m.cidx(j); i < m.cidx(j+1); i++)
+for (octave_idx_type i = m.cidx (j); i < m.cidx (j+1); i++)
-result.xdata(m.ridx(i) + j * nr) = xmax (c, m.data(i));
+result.xdata (m.ridx (i) + j * nr) = xmax (c, m.data (i));
 }
 else
 result = SparseComplexMatrix (m);
 return result;
 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 = a.cidx (i);
-octave_idx_type  ja_max = a.cidx(i+1);
+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 = b.cidx (i);
-octave_idx_type  jb_max = b.cidx(i+1);
+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) ||
-(ja_lt_max && (a.ridx(ja) < b.ridx(jb))))
+(ja_lt_max && (a.ridx (ja) < b.ridx (jb))))
 {
-Complex tmp = xmax (a.data(ja), 0.);
+Complex tmp = xmax (a.data (ja), 0.);
 if (tmp != 0.)
 {
-r.ridx(jx) = a.ridx(ja);
+r.ridx (jx) = a.ridx (ja);
-r.data(jx) = tmp;
+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)) ) )
+(jb_lt_max && (b.ridx (jb) < a.ridx (ja)) ) )
 {
-Complex tmp = xmax (0., b.data(jb));
+Complex tmp = xmax (0., b.data (jb));
 if (tmp != 0.)
 {
-r.ridx(jx) = b.ridx(jb);
+r.ridx (jx) = b.ridx (jb);
-r.data(jx) = tmp;
+r.data (jx) = tmp;
 jx++;
 }
 jb++;
 jb_lt_max= jb < jb_max;
 }
 else
 {
-Complex tmp = xmax (a.data(ja), b.data(jb));
+Complex tmp = xmax (a.data (ja), b.data (jb));
 if (tmp != 0.)
 {
-r.data(jx) = tmp;
+r.data (jx) = tmp;
-r.ridx(jx) = a.ridx(ja);
+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.cidx (i+1) = jx;
 }
 r.maybe_compress ();
 }
 }

Mercurial > hg > octave-lyh

comparison liboctave/CSparse.cc @ 15018:3d8ace26c5b4