diff --git a/Eigen/src/SparseCore/SparseMatrix.h b/Eigen/src/SparseCore/SparseMatrix.h
index ba32e48..9ad8e4a 100644
--- a/Eigen/src/SparseCore/SparseMatrix.h
+++ b/Eigen/src/SparseCore/SparseMatrix.h
@@ -237,23 +237,23 @@
       eigen_assert(row>=0 && row<rows() && col>=0 && col<cols());
       const Index outer = IsRowMajor ? row : col;
       const Index inner = IsRowMajor ? col : row;
-      Index start = outerIndexPtr()[outer];
-      Index end = isCompressed() ? outerIndexPtr()[outer + 1] : outerIndexPtr()[outer] + innerNonZeroPtr()[outer];
+      Index start = m_outerIndex[outer];
+      Index end = isCompressed() ? m_outerIndex[outer + 1] : m_outerIndex[outer] + m_innerNonZeros[outer];
       eigen_assert(end >= start && "you probably called coeffRef on a non finalized matrix");
-      Index dst = start == end ? end : data().searchLowerIndex(start, end, inner);
+      Index dst = start == end ? end : m_data.searchLowerIndex(start, end, inner);
       if (dst == end) {
-        Index capacity = outerIndexPtr()[outer + 1] - end;
+        Index capacity = m_outerIndex[outer + 1] - end;
         if (capacity > 0) {
           // implies uncompressed: push to back of vector
-          innerNonZeroPtr()[outer]++;
-          data().index(end) = inner;
-          data().value(end) = Scalar(0);
-          return data().value(end);
+          m_innerNonZeros[outer]++;
+          m_data.index(end) = inner;
+          m_data.value(end) = Scalar(0);
+          return m_data.value(end);
         }
       }
-      if ((dst < end) && (data().index(dst) == inner))
+      if ((dst < end) && (m_data.index(dst) == inner))
         // this coefficient exists, return a refernece to it
-        return data().value(dst);
+        return m_data.value(dst);
       else
         // insertion will require reconfiguring the buffer
         return insertAtByOuterInner(outer, inner, dst);
@@ -383,7 +383,7 @@
           Index alreadyReserved = internal::convert_index<Index>(m_outerIndex[j+1] - m_outerIndex[j] - m_innerNonZeros[j]);
           Index reserveSize = internal::convert_index<Index>(reserveSizes[j]);
           Index toReserve = numext::maxi(reserveSize, alreadyReserved);
-          count += toReserve + m_innerNonZeros[j];
+          count += toReserve + internal::convert_index<Index>(m_innerNonZeros[j]);
         }
         newOuterIndex[m_outerSize] = internal::convert_index<StorageIndex>(count);
 
@@ -394,7 +394,7 @@
           StorageIndex begin = m_outerIndex[j];
           StorageIndex end = begin + innerNNZ;
           StorageIndex target = newOuterIndex[j];
-          data().moveChunk(begin, target, innerNNZ);
+          m_data.moveChunk(begin, target, innerNNZ);
         }
         
         std::swap(m_outerIndex, newOuterIndex);
@@ -496,20 +496,20 @@
       * same as insert(Index,Index) except that the indices are given relative to the storage order */
     Scalar& insertByOuterInner(Index j, Index i)
     {
-      Index start = outerIndexPtr()[j];
-      Index end = isCompressed() ? outerIndexPtr()[j + 1] : start + innerNonZeroPtr()[j];
-      Index dst = start == end ? end : data().searchLowerIndex(start, end, i);
+      Index start = m_outerIndex[j];
+      Index end = isCompressed() ? m_outerIndex[j + 1] : start + m_innerNonZeros[j];
+      Index dst = start == end ? end : m_data.searchLowerIndex(start, end, i);
       if (dst == end) {
-        Index capacity = outerIndexPtr()[j + 1] - end;
+        Index capacity = m_outerIndex[j + 1] - end;
         if (capacity > 0) {
           // implies uncompressed: push to back of vector
-          innerNonZeroPtr()[j]++;
-          data().index(end) = i;
-          data().value(end) = Scalar(0);
-          return data().value(end);
+          m_innerNonZeros[j]++;
+          m_data.index(end) = i;
+          m_data.value(end) = Scalar(0);
+          return m_data.value(end);
         }
       }
-      eigen_assert((dst == end || data().index(dst) != i) &&
+      eigen_assert((dst == end || m_data.index(dst) != i) &&
           "you cannot insert an element that already exists, you must call coeffRef to this end");
       return insertAtByOuterInner(j, i, dst);
     }
@@ -520,46 +520,46 @@
     {
       if (isCompressed()) return;
       
-      eigen_internal_assert(outerIndexPtr()!=0 && outerSize()>0);
+      eigen_internal_assert(m_outerIndex!=0 && m_outerSize>0);
 
-      StorageIndex start = outerIndexPtr()[1];
-      outerIndexPtr()[1] = innerNonZeroPtr()[0];
+      StorageIndex start = m_outerIndex[1];
+      m_outerIndex[1] = m_innerNonZeros[0];
       // try to move fewer, larger contiguous chunks
       Index copyStart = start;
-      Index copyTarget = innerNonZeroPtr()[0];
-      for (Index j = 1; j < outerSize(); j++)
+      Index copyTarget = m_innerNonZeros[0];
+      for (Index j = 1; j < m_outerSize; j++)
       {
-        Index end = start + innerNonZeroPtr()[j];
-        Index nextStart = outerIndexPtr()[j + 1];
+        Index end = start + m_innerNonZeros[j];
+        Index nextStart = m_outerIndex[j + 1];
         // dont forget to move the last chunk!
-        bool breakUpCopy = (end != nextStart) || (j == outerSize() - 1);
+        bool breakUpCopy = (end != nextStart) || (j == m_outerSize - 1);
         if (breakUpCopy)
         {
           Index chunkSize = end - copyStart;
-          data().moveChunk(copyStart, copyTarget, chunkSize);
+          if(chunkSize > 0) m_data.moveChunk(copyStart, copyTarget, chunkSize);
           copyStart = nextStart;
           copyTarget += chunkSize;
         }
         start = nextStart;
-        outerIndexPtr()[j + 1] = outerIndexPtr()[j] + innerNonZeroPtr()[j];
+        m_outerIndex[j + 1] = m_outerIndex[j] + m_innerNonZeros[j];
       }
-      data().resize(outerIndexPtr()[outerSize()]);
+      m_data.resize(m_outerIndex[m_outerSize]);
 
       // release as much memory as possible
-      internal::conditional_aligned_delete_auto<StorageIndex, true>(innerNonZeroPtr(), outerSize());
+      internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
       m_innerNonZeros = 0;
-      data().squeeze();
+      m_data.squeeze();
     }
 
     /** Turns the matrix into the uncompressed mode */
     void uncompress()
     {
       if (!isCompressed()) return;
-      m_innerNonZeros = internal::conditional_aligned_new_auto<StorageIndex, true>(outerSize());
-      if (outerIndexPtr()[outerSize()] == 0)
-        std::fill_n(innerNonZeroPtr(), outerSize(), StorageIndex(0));
+      m_innerNonZeros = internal::conditional_aligned_new_auto<StorageIndex, true>(m_outerSize);
+      if (m_outerIndex[m_outerSize] == 0)
+        std::fill_n(m_innerNonZeros, m_outerSize, StorageIndex(0));
       else
-        for (Index j = 0; j < outerSize(); j++) innerNonZeroPtr()[j] = outerIndexPtr()[j + 1] - outerIndexPtr()[j];
+        for (Index j = 0; j < m_outerSize; j++) m_innerNonZeros[j] = m_outerIndex[j + 1] - m_outerIndex[j];
     }
 
     /** Suppresses all nonzeros which are \b much \b smaller \b than \a reference under the tolerance \a epsilon */
@@ -622,40 +622,40 @@
       Index newOuterSize = IsRowMajor ? rows : cols;
       Index newInnerSize = IsRowMajor ? cols : rows;
 
-      Index innerChange = newInnerSize - innerSize();
-      Index outerChange = newOuterSize - outerSize();
+      Index innerChange = newInnerSize - m_innerSize;
+      Index outerChange = newOuterSize - m_outerSize;
 
       if (outerChange != 0) {
         m_outerIndex = internal::conditional_aligned_realloc_new_auto<StorageIndex, true>(
-            outerIndexPtr(), newOuterSize + 1, outerSize() + 1);
+            m_outerIndex, newOuterSize + 1, m_outerSize + 1);
 
         if (!isCompressed())
           m_innerNonZeros = internal::conditional_aligned_realloc_new_auto<StorageIndex, true>(
-              innerNonZeroPtr(), newOuterSize, outerSize());
+              m_innerNonZeros, newOuterSize, m_outerSize);
 
         if (outerChange > 0) {
-          StorageIndex lastIdx = outerSize() == 0 ? StorageIndex(0) : outerIndexPtr()[outerSize()];
-          std::fill_n(outerIndexPtr() + outerSize(), outerChange + 1, lastIdx);
+          StorageIndex lastIdx = m_outerSize == 0 ? StorageIndex(0) : m_outerIndex[m_outerSize];
+          std::fill_n(m_outerIndex + m_outerSize, outerChange + 1, lastIdx);
 
-          if (!isCompressed()) std::fill_n(innerNonZeroPtr() + outerSize(), outerChange, StorageIndex(0));
+          if (!isCompressed()) std::fill_n(m_innerNonZeros + m_outerSize, outerChange, StorageIndex(0));
         }
       }
       m_outerSize = newOuterSize;
 
       if (innerChange < 0) {
-        for (Index j = 0; j < outerSize(); j++) {
-          Index start = outerIndexPtr()[j];
-          Index end = isCompressed() ? outerIndexPtr()[j + 1] : start + innerNonZeroPtr()[j];
-          Index lb = data().searchLowerIndex(start, end, newInnerSize);
+        for (Index j = 0; j < m_outerSize; j++) {
+          Index start = m_outerIndex[j];
+          Index end = isCompressed() ? m_outerIndex[j + 1] : start + m_innerNonZeros[j];
+          Index lb = m_data.searchLowerIndex(start, end, newInnerSize);
           if (lb != end) {
             uncompress();
-            innerNonZeroPtr()[j] = StorageIndex(lb - start);
+            m_innerNonZeros[j] = StorageIndex(lb - start);
           }
         }
       }
       m_innerSize = newInnerSize;
 
-      Index newSize = outerIndexPtr()[outerSize()];
+      Index newSize = m_outerIndex[m_outerSize];
       eigen_assert(newSize <= m_data.size());
       m_data.resize(newSize);
     }
@@ -803,17 +803,17 @@
       * This function also turns the matrix into compressed mode, and drop any reserved memory. */
     inline void setIdentity()
     {
-      eigen_assert(rows() == cols() && "ONLY FOR SQUARED MATRICES");
+      eigen_assert(m_outerSize == m_innerSize && "ONLY FOR SQUARED MATRICES");
       if (m_innerNonZeros) {
         internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
         m_innerNonZeros = 0;
       }
-      m_data.resize(rows());
+      m_data.resize(m_outerSize);
       // is it necessary to squeeze?
       m_data.squeeze();
-      std::iota(outerIndexPtr(), outerIndexPtr() + rows() + 1, StorageIndex(0));
-      std::iota(innerIndexPtr(), innerIndexPtr() + rows(), StorageIndex(0));
-      std::fill_n(valuePtr(), rows(), Scalar(1));
+      std::iota(m_outerIndex, m_outerIndex + m_outerSize + 1, StorageIndex(0));
+      std::iota(innerIndexPtr(), innerIndexPtr() + m_outerSize, StorageIndex(0));
+      std::fill_n(valuePtr(), m_outerSize, Scalar(1));
     }
 
     inline SparseMatrix& operator=(const SparseMatrix& other)
@@ -998,11 +998,11 @@
       const bool overwrite = internal::is_same<Func, internal::assign_op<Scalar,Scalar> >::value;
       if(overwrite)
       {
-        if((this->rows()!=n) || (this->cols()!=n))
-          this->resize(n, n);
+        if((m_outerSize != n) || (m_innerSize != n))
+          resize(n, n);
       }
 
-      if(data().size()==0 || overwrite)
+      if(m_data.size()==0 || overwrite)
       {
         if (!isCompressed()) {
           internal::conditional_aligned_delete_auto<StorageIndex, true>(m_innerNonZeros, m_outerSize);
@@ -1010,7 +1010,7 @@
         }
         resizeNonZeros(n);
         ValueMap valueMap(valuePtr(), n);
-        std::iota(outerIndexPtr(), outerIndexPtr() + n + 1, StorageIndex(0));
+        std::iota(m_outerIndex, m_outerIndex + n + 1, StorageIndex(0));
         std::iota(innerIndexPtr(), innerIndexPtr() + n, StorageIndex(0));
         valueMap.setZero();
         internal::call_assignment_no_alias(valueMap, diagXpr, assignFunc);
@@ -1027,12 +1027,12 @@
           Index shift = 0;
 
           for (Index j = 0; j < n; j++) {
-            Index begin = outerIndexPtr()[j];
-            Index end = isCompressed() ? outerIndexPtr()[j + 1] : begin + innerNonZeroPtr()[j];
-            Index capacity = outerIndexPtr()[j + 1] - end;
-            Index dst = data().searchLowerIndex(begin, end, j);
+            Index begin = m_outerIndex[j];
+            Index end = isCompressed() ? m_outerIndex[j + 1] : begin + m_innerNonZeros[j];
+            Index capacity = m_outerIndex[j + 1] - end;
+            Index dst = m_data.searchLowerIndex(begin, end, j);
             // the entry exists: update it now
-            if (dst != end && data().index(dst) == j) assignFunc.assignCoeff(data().value(dst), diaEval.coeff(j));
+            if (dst != end && m_data.index(dst) == j) assignFunc.assignCoeff(m_data.value(dst), diaEval.coeff(j));
             // the entry belongs at the back of the vector: push to back
             else if (dst == end && capacity > 0)
               assignFunc.assignCoeff(insertBackUncompressed(j, j), diaEval.coeff(j));
@@ -1047,13 +1047,13 @@
           
           if (deferredInsertions > 0) {
 
-            data().resize(data().size() + shift);
-            Index copyEnd = isCompressed() ? outerIndexPtr()[outerSize()]
-                                           : outerIndexPtr()[outerSize() - 1] + innerNonZeroPtr()[outerSize() - 1];
-            for (Index j = outerSize() - 1; deferredInsertions > 0; j--) {
-              Index begin = outerIndexPtr()[j];
-              Index end = isCompressed() ? outerIndexPtr()[j + 1] : begin + innerNonZeroPtr()[j];
-              Index capacity = outerIndexPtr()[j + 1] - end;
+            m_data.resize(m_data.size() + shift);
+            Index copyEnd = isCompressed() ? m_outerIndex[m_outerSize]
+                                           : m_outerIndex[m_outerSize - 1] + m_innerNonZeros[m_outerSize - 1];
+            for (Index j = m_outerSize - 1; deferredInsertions > 0; j--) {
+              Index begin = m_outerIndex[j];
+              Index end = isCompressed() ? m_outerIndex[j + 1] : begin + m_innerNonZeros[j];
+              Index capacity = m_outerIndex[j + 1] - end;
 
               bool doInsertion = insertionLocations(j) >= 0;
               bool breakUpCopy = doInsertion && (capacity > 0);
@@ -1062,14 +1062,14 @@
               // where `threshold >= 0` to skip inactive nonzeros in each vector
               // this reduces the total number of copied elements, but requires more moveChunk calls
               if (breakUpCopy) {
-                Index copyBegin = outerIndexPtr()[j + 1];
+                Index copyBegin = m_outerIndex[j + 1];
                 Index to = copyBegin + shift;
                 Index chunkSize = copyEnd - copyBegin;
-                data().moveChunk(copyBegin, to, chunkSize);
+                m_data.moveChunk(copyBegin, to, chunkSize);
                 copyEnd = end;
               }
 
-              outerIndexPtr()[j + 1] += shift;
+              m_outerIndex[j + 1] += shift;
               
               if (doInsertion) {
                 // if there is capacity, shift into the inactive nonzeros
@@ -1077,12 +1077,12 @@
                 Index copyBegin = insertionLocations(j);
                 Index to = copyBegin + shift;
                 Index chunkSize = copyEnd - copyBegin;
-                data().moveChunk(copyBegin, to, chunkSize);
+                m_data.moveChunk(copyBegin, to, chunkSize);
                 Index dst = to - 1;
-                data().index(dst) = StorageIndex(j);
-                data().value(dst) = Scalar(0);
-                assignFunc.assignCoeff(data().value(dst), diaEval.coeff(j));
-                if (!isCompressed()) innerNonZeroPtr()[j]++;
+                m_data.index(dst) = StorageIndex(j);
+                m_data.value(dst) = Scalar(0);
+                assignFunc.assignCoeff(m_data.value(dst), diaEval.coeff(j));
+                if (!isCompressed()) m_innerNonZeros[j]++;
                 shift--;
                 deferredInsertions--;
                 copyEnd = copyBegin;
@@ -1442,20 +1442,20 @@
   eigen_assert(!isCompressed());
   Index outer = IsRowMajor ? row : col;
   Index inner = IsRowMajor ? col : row;
-  Index start = outerIndexPtr()[outer];
-  Index end = start + innerNonZeroPtr()[outer];
-  Index dst = start == end ? end : data().searchLowerIndex(start, end, inner);
+  Index start = m_outerIndex[outer];
+  Index end = start + m_innerNonZeros[outer];
+  Index dst = start == end ? end : m_data.searchLowerIndex(start, end, inner);
   if (dst == end) {
-    Index capacity = outerIndexPtr()[outer + 1] - end;
+    Index capacity = m_outerIndex[outer + 1] - end;
     if (capacity > 0) {
       // implies uncompressed: push to back of vector
-      innerNonZeroPtr()[outer]++;
-      data().index(end) = inner;
-      data().value(end) = Scalar(0);
-      return data().value(end);
+      m_innerNonZeros[outer]++;
+      m_data.index(end) = inner;
+      m_data.value(end) = Scalar(0);
+      return m_data.value(end);
     }
   }
-  eigen_assert((dst == end || data().index(dst) != inner) &&
+  eigen_assert((dst == end || m_data.index(dst) != inner) &&
                "you cannot insert an element that already exists, you must call coeffRef to this end");
   return insertUncompressedAtByOuterInner(outer, inner, dst);
 }
@@ -1466,10 +1466,10 @@
   eigen_assert(isCompressed());
   Index outer = IsRowMajor ? row : col;
   Index inner = IsRowMajor ? col : row;
-  Index start = outerIndexPtr()[outer];
-  Index end = outerIndexPtr()[outer + 1];
-  Index dst = start == end ? end : data().searchLowerIndex(start, end, inner);
-  eigen_assert((dst == end || data().index(dst) != inner) &&
+  Index start = m_outerIndex[outer];
+  Index end = m_outerIndex[outer + 1];
+  Index dst = start == end ? end : m_data.searchLowerIndex(start, end, inner);
+  eigen_assert((dst == end || m_data.index(dst) != inner) &&
                "you cannot insert an element that already exists, you must call coeffRef to this end");
   return insertCompressedAtByOuterInner(outer, inner, dst);
 }
@@ -1480,25 +1480,25 @@
   eigen_assert(isCompressed());
   // compressed insertion always requires expanding the buffer
   // first, check if there is adequate allocated memory
-  if (data().allocatedSize() <= data().size()) {
+  if (m_data.allocatedSize() <= m_data.size()) {
     // if there is no capacity for a single insertion, double the capacity
     // increase capacity by a mininum of 32
     Index minReserve = 32;
-    Index reserveSize = numext::maxi(minReserve, data().allocatedSize());
-    data().reserve(reserveSize);
+    Index reserveSize = numext::maxi(minReserve, m_data.allocatedSize());
+    m_data.reserve(reserveSize);
   }
-  data().resize(data().size() + 1);
-  Index chunkSize = outerIndexPtr()[outerSize()] - dst;
+  m_data.resize(m_data.size() + 1);
+  Index chunkSize = m_outerIndex[m_outerSize] - dst;
   // shift the existing data to the right if necessary
-  data().moveChunk(dst, dst + 1, chunkSize);
+  m_data.moveChunk(dst, dst + 1, chunkSize);
   // update nonzero counts
   // potentially O(outerSize) bottleneck!
-  for (Index j = outer; j < outerSize(); j++) outerIndexPtr()[j + 1]++;
+  for (Index j = outer; j < m_outerSize; j++) m_outerIndex[j + 1]++;
   // initialize the coefficient
-  data().index(dst) = StorageIndex(inner);
-  data().value(dst) = Scalar(0);
+  m_data.index(dst) = StorageIndex(inner);
+  m_data.value(dst) = Scalar(0);
   // return a reference to the coefficient
-  return data().value(dst);
+  return m_data.value(dst);
 }
 
 template <typename Scalar_, int Options_, typename StorageIndex_>
@@ -1506,79 +1506,79 @@
 SparseMatrix<Scalar_, Options_, StorageIndex_>::insertUncompressedAtByOuterInner(Index outer, Index inner, Index dst) {
   eigen_assert(!isCompressed());
   // find a vector with capacity, starting at `outer` and searching to the left and right
-  for (Index leftTarget = outer - 1, rightTarget = outer; (leftTarget >= 0) || (rightTarget < outerSize());) {
-    if (rightTarget < outerSize()) {
-      Index start = outerIndexPtr()[rightTarget];
-      Index end = start + innerNonZeroPtr()[rightTarget];
-      Index nextStart = outerIndexPtr()[rightTarget + 1];
+  for (Index leftTarget = outer - 1, rightTarget = outer; (leftTarget >= 0) || (rightTarget < m_outerSize);) {
+    if (rightTarget < m_outerSize) {
+      Index start = m_outerIndex[rightTarget];
+      Index end = start + m_innerNonZeros[rightTarget];
+      Index nextStart = m_outerIndex[rightTarget + 1];
       Index capacity = nextStart - end;
       if (capacity > 0) {
         // move [dst, end) to dst+1 and insert at dst
         Index chunkSize = end - dst;
-        if (chunkSize > 0) data().moveChunk(dst, dst + 1, chunkSize);
-        innerNonZeroPtr()[outer]++;
-        for (Index j = outer; j < rightTarget; j++) outerIndexPtr()[j + 1]++;
-        data().index(dst) = StorageIndex(inner);
-        data().value(dst) = Scalar(0);
-        return data().value(dst);
+        if (chunkSize > 0) m_data.moveChunk(dst, dst + 1, chunkSize);
+        m_innerNonZeros[outer]++;
+        for (Index j = outer; j < rightTarget; j++) m_outerIndex[j + 1]++;
+        m_data.index(dst) = StorageIndex(inner);
+        m_data.value(dst) = Scalar(0);
+        return m_data.value(dst);
       }
       rightTarget++;
     }
     if (leftTarget >= 0) {
-      Index start = outerIndexPtr()[leftTarget];
-      Index end = start + innerNonZeroPtr()[leftTarget];
-      Index nextStart = outerIndexPtr()[leftTarget + 1];
+      Index start = m_outerIndex[leftTarget];
+      Index end = start + m_innerNonZeros[leftTarget];
+      Index nextStart = m_outerIndex[leftTarget + 1];
       Index capacity = nextStart - end;
       if (capacity > 0) {
         // tricky: dst is a lower bound, so we must insert at dst-1 when shifting left
         // move [nextStart, dst) to nextStart-1 and insert at dst-1
         Index chunkSize = dst - nextStart;
-        if (chunkSize > 0) data().moveChunk(nextStart, nextStart - 1, chunkSize);
-        innerNonZeroPtr()[outer]++;
-        for (Index j = leftTarget; j < outer; j++) outerIndexPtr()[j + 1]--;
-        data().index(dst - 1) = StorageIndex(inner);
-        data().value(dst - 1) = Scalar(0);
-        return data().value(dst - 1);
+        if (chunkSize > 0) m_data.moveChunk(nextStart, nextStart - 1, chunkSize);
+        m_innerNonZeros[outer]++;
+        for (Index j = leftTarget; j < outer; j++) m_outerIndex[j + 1]--;
+        m_data.index(dst - 1) = StorageIndex(inner);
+        m_data.value(dst - 1) = Scalar(0);
+        return m_data.value(dst - 1);
       }
       leftTarget--;
     }
   }
 
   // no room for interior insertion
-  // nonZeros() == data().size()
+  // nonZeros() == m_data.size()
   // record offset as outerIndxPtr will change
-  Index dst_offset = dst - outerIndexPtr()[outer];
+  Index dst_offset = dst - m_outerIndex[outer];
   // allocate space for random insertion
-  if (data().allocatedSize() == 0) {
+  if (m_data.allocatedSize() == 0) {
     // fast method to allocate space for one element per vector in empty matrix
-    data().resize(outerSize());
-    std::iota(outerIndexPtr(), outerIndexPtr() + outerSize() + 1, StorageIndex(0));
+    m_data.resize(m_outerSize);
+    std::iota(m_outerIndex, m_outerIndex + m_outerSize + 1, StorageIndex(0));
   } else {
     // check for integer overflow: if maxReserveSize == 0, insertion is not possible
-    Index maxReserveSize = static_cast<Index>(NumTraits<StorageIndex>::highest()) - data().allocatedSize();
+    Index maxReserveSize = static_cast<Index>(NumTraits<StorageIndex>::highest()) - m_data.allocatedSize();
     eigen_assert(maxReserveSize > 0);
-    if (outerSize() <= maxReserveSize) {
+    if (m_outerSize <= maxReserveSize) {
       // allocate space for one additional element per vector
-      reserveInnerVectors(IndexVector::Constant(outerSize(), 1));
+      reserveInnerVectors(IndexVector::Constant(m_outerSize, 1));
     } else {
       // handle the edge case where StorageIndex is insufficient to reserve outerSize additional elements
       // allocate space for one additional element in the interval [outer,maxReserveSize)
       typedef internal::sparse_reserve_op<StorageIndex> ReserveSizesOp;
       typedef CwiseNullaryOp<ReserveSizesOp, IndexVector> ReserveSizesXpr;
-      ReserveSizesXpr reserveSizesXpr(outerSize(), 1, ReserveSizesOp(outer, outerSize(), maxReserveSize));
+      ReserveSizesXpr reserveSizesXpr(m_outerSize, 1, ReserveSizesOp(outer, m_outerSize, maxReserveSize));
       reserveInnerVectors(reserveSizesXpr);
     }
   }
   // insert element at `dst` with new outer indices
-  Index start = outerIndexPtr()[outer];
-  Index end = start + innerNonZeroPtr()[outer];
+  Index start = m_outerIndex[outer];
+  Index end = start + m_innerNonZeros[outer];
   Index new_dst = start + dst_offset;
   Index chunkSize = end - new_dst;
-  if (chunkSize > 0) data().moveChunk(new_dst, new_dst + 1, chunkSize);
-  innerNonZeroPtr()[outer]++;
-  data().index(new_dst) = StorageIndex(inner);
-  data().value(new_dst) = Scalar(0);
-  return data().value(new_dst);
+  if (chunkSize > 0) m_data.moveChunk(new_dst, new_dst + 1, chunkSize);
+  m_innerNonZeros[outer]++;
+  m_data.index(new_dst) = StorageIndex(inner);
+  m_data.value(new_dst) = Scalar(0);
+  return m_data.value(new_dst);
 }
 
 namespace internal {