diff --git a/python_numpy/python_numpy_base_simplification.hpp b/python_numpy/python_numpy_base_simplification.hpp
index 7705918..668003c 100644
--- a/python_numpy/python_numpy_base_simplification.hpp
+++ b/python_numpy/python_numpy_base_simplification.hpp
@@ -732,26 +732,40 @@ struct RepeatMatrix<0, MATRIX_Type, Args...> {
 
 template <std::size_t M, std::size_t N, typename MATRIX_Type,
           std::size_t... Indices>
-inline auto implement(const MATRIX_Type &matrix,
-                      index_sequence_for_tile<Indices...>)
-    -> Tile_Type<M, N, MATRIX_Type> {
+inline void calculate(Tile_Type<M, N, MATRIX_Type> &Concatenated,
+                      const MATRIX_Type &matrix,
+                      index_sequence_for_tile<Indices...>) {
 
-  return concatenate_block<M, N>((static_cast<void>(Indices), matrix)...);
+  update_block_concatenated_matrix<M, N>(
+      Concatenated, (static_cast<void>(Indices), matrix)...);
 }
 
 } // namespace TileOperation
 
 template <std::size_t M, std::size_t N, typename MATRIX_Type>
-inline auto concatenate_tile(const MATRIX_Type &matrix)
-    -> Tile_Type<M, N, MATRIX_Type> {
+inline void
+update_tile_concatenated_matrix(Tile_Type<M, N, MATRIX_Type> &Concatenated,
+                                const MATRIX_Type &matrix) {
 
   static_assert(M > 0, "M must be greater than 0.");
   static_assert(N > 0, "N must be greater than 0.");
 
   constexpr std::size_t TotalCount = M * N;
 
-  return TileOperation::implement<M, N>(
-      matrix, TileOperation::make_index_sequence_for_tile<TotalCount>{});
+  TileOperation::calculate<M, N>(
+      Concatenated, matrix,
+      TileOperation::make_index_sequence_for_tile<TotalCount>{});
+}
+
+template <std::size_t M, std::size_t N, typename MATRIX_Type>
+inline auto concatenate_tile(const MATRIX_Type &matrix)
+    -> Tile_Type<M, N, MATRIX_Type> {
+
+  Tile_Type<M, N, MATRIX_Type> Concatenated;
+
+  update_tile_concatenated_matrix<M, N>(Concatenated, matrix);
+
+  return Concatenated;
 }
 
 } // namespace PythonNumpy
diff --git a/python_numpy/python_numpy_linalg_cholesky.hpp b/python_numpy/python_numpy_linalg_cholesky.hpp
index 1ec83c2..ff897d6 100644
--- a/python_numpy/python_numpy_linalg_cholesky.hpp
+++ b/python_numpy/python_numpy_linalg_cholesky.hpp
@@ -30,9 +30,19 @@ template <typename A_Type> class LinalgSolverCholesky {
   /* Type */
   using _T = typename A_Type::Value_Type;
 
+  using _CholeskyTriangularRowIndices =
+      UpperTriangularRowIndices<A_Type::COLS, A_Type::COLS>;
+  using _CholeskyTriangularRowPointers =
+      UpperTriangularRowPointers<A_Type::COLS, A_Type::COLS>;
+
 public:
   /* Constructor */
-  LinalgSolverCholesky() {}
+  LinalgSolverCholesky()
+      : _cholesky_decomposed_matrix(),
+        _cholesky_decomposed_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_upper()),
+        _zero_div_flag(false) {}
 
   /* Copy Constructor */
   LinalgSolverCholesky(const LinalgSolverCholesky<A_Type> &other)
@@ -151,14 +161,13 @@ template <typename A_Type> class LinalgSolverCholesky {
   /* Variable */
   Base::Matrix::Matrix<_T, A_Type::COLS, A_Type::COLS>
       _cholesky_decomposed_matrix;
-  Base::Matrix::CompiledSparseMatrix<
-      _T, A_Type::COLS, A_Type::COLS,
-      UpperTriangularRowIndices<A_Type::COLS, A_Type::COLS>,
-      UpperTriangularRowPointers<A_Type::COLS, A_Type::COLS>>
-      _cholesky_decomposed_triangular =
-          Base::Matrix::TriangularSparse<_T, A_Type::COLS,
-                                         A_Type::COLS>::create_upper();
-  bool _zero_div_flag = false;
+
+  Base::Matrix::CompiledSparseMatrix<_T, A_Type::COLS, A_Type::COLS,
+                                     _CholeskyTriangularRowIndices,
+                                     _CholeskyTriangularRowPointers>
+      _cholesky_decomposed_triangular;
+
+  bool _zero_div_flag;
 };
 
 /* make LinalgSolverCholesky */
diff --git a/python_numpy/python_numpy_linalg_eig.hpp b/python_numpy/python_numpy_linalg_eig.hpp
index b855070..b7b39ac 100644
--- a/python_numpy/python_numpy_linalg_eig.hpp
+++ b/python_numpy/python_numpy_linalg_eig.hpp
@@ -32,7 +32,7 @@ template <typename T, std::size_t M> class LinalgSolverEigRealDense {
 
 public:
   /* Constructor */
-  LinalgSolverEigRealDense() {}
+  LinalgSolverEigRealDense() : _Eigen_solver() {}
 
   /* Copy Constructor */
   LinalgSolverEigRealDense(const LinalgSolverEigRealDense<T, M> &other)
@@ -136,7 +136,7 @@ template <typename T, std::size_t M> class LinalgSolverEigRealDiag {
 
 public:
   /* Constructor */
-  LinalgSolverEigRealDiag() {}
+  LinalgSolverEigRealDiag() : _eigen_values() {}
 
   /* Copy Constructor */
   LinalgSolverEigRealDiag(const LinalgSolverEigRealDiag<T, M> &other)
@@ -208,7 +208,7 @@ class LinalgSolverEigRealSparse {
 
 public:
   /* Constructor */
-  LinalgSolverEigRealSparse() {}
+  LinalgSolverEigRealSparse() : _Eigen_solver() {}
 
   /* Copy Constructor */
   LinalgSolverEigRealSparse(
@@ -362,7 +362,7 @@ template <typename T, std::size_t M> class LinalgSolverEigDense {
 
 public:
   /* Constructor */
-  LinalgSolverEigDense() {}
+  LinalgSolverEigDense() : _Eigen_solver() {}
 
   /* Copy Constructor */
   LinalgSolverEigDense(const LinalgSolverEigDense<T, M> &other)
@@ -477,7 +477,7 @@ template <typename T, std::size_t M> class LinalgSolverEigDiag {
 
 public:
   /* Constructor */
-  LinalgSolverEigDiag() {}
+  LinalgSolverEigDiag() : _eigen_values() {}
 
   /* Copy Constructor */
   LinalgSolverEigDiag(const LinalgSolverEigDiag<T, M> &other)
diff --git a/python_numpy/python_numpy_linalg_lu.hpp b/python_numpy/python_numpy_linalg_lu.hpp
index a7d2763..1286e8a 100644
--- a/python_numpy/python_numpy_linalg_lu.hpp
+++ b/python_numpy/python_numpy_linalg_lu.hpp
@@ -37,23 +37,54 @@ template <typename A_Type> class LinalgSolverLU {
   /* Type */
   using _T = typename A_Type::Value_Type;
 
+  using _L_RowIndices =
+      Base::Matrix::LowerTriangularRowIndices<A_Type::COLS, A_Type::COLS>;
+  using _L_RowPointers =
+      Base::Matrix::LowerTriangularRowPointers<A_Type::COLS, A_Type::COLS>;
+
+  using _U_RowIndices =
+      Base::Matrix::UpperTriangularRowIndices<A_Type::COLS, A_Type::COLS>;
+  using _U_RowPointers =
+      Base::Matrix::UpperTriangularRowPointers<A_Type::COLS, A_Type::COLS>;
+
 public:
   /* Constructor */
   template <
       typename U = A_Type,
       typename std::enable_if<Is_Dense_Matrix<U>::value>::type * = nullptr>
-  LinalgSolverLU() {
+  LinalgSolverLU()
+      : _LU_decomposer(),
+        _L_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_lower()),
+        _U_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_upper()) {
     this->_LU_decomposer = Base::Matrix::LUDecomposition<_T, A_Type::COLS>();
   }
 
   template <typename U = A_Type,
             typename std::enable_if<Is_Diag_Matrix<U>::value>::type * = nullptr>
-  LinalgSolverLU() {}
+  LinalgSolverLU()
+      : _LU_decomposer(),
+        _L_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_lower()),
+        _U_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_upper()) {}
 
   template <
       typename U = A_Type,
       typename std::enable_if<Is_Sparse_Matrix<U>::value>::type * = nullptr>
-  LinalgSolverLU() {
+  LinalgSolverLU()
+      : _LU_decomposer(),
+        _L_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_lower()),
+        _U_triangular(
+            Base::Matrix::TriangularSparse<_T, A_Type::COLS,
+                                           A_Type::COLS>::create_upper()) {
     this->_LU_decomposer = Base::Matrix::LUDecomposition<_T, A_Type::COLS>();
   }
 
@@ -144,21 +175,14 @@ template <typename A_Type> class LinalgSolverLU {
 private:
   /* Variable */
   Base::Matrix::LUDecomposition<_T, A_Type::COLS> _LU_decomposer;
-  Base::Matrix::CompiledSparseMatrix<
-      _T, A_Type::COLS, A_Type::COLS,
-      Base::Matrix::LowerTriangularRowIndices<A_Type::COLS, A_Type::COLS>,
-      Base::Matrix::LowerTriangularRowPointers<A_Type::COLS, A_Type::COLS>>
-      _L_triangular =
-          Base::Matrix::TriangularSparse<_T, A_Type::COLS,
-                                         A_Type::COLS>::create_lower();
-
-  Base::Matrix::CompiledSparseMatrix<
-      _T, A_Type::COLS, A_Type::COLS,
-      Base::Matrix::UpperTriangularRowIndices<A_Type::COLS, A_Type::COLS>,
-      Base::Matrix::UpperTriangularRowPointers<A_Type::COLS, A_Type::COLS>>
-      _U_triangular =
-          Base::Matrix::TriangularSparse<_T, A_Type::COLS,
-                                         A_Type::COLS>::create_upper();
+
+  Base::Matrix::CompiledSparseMatrix<_T, A_Type::COLS, A_Type::COLS,
+                                     _L_RowIndices, _L_RowPointers>
+      _L_triangular;
+
+  Base::Matrix::CompiledSparseMatrix<_T, A_Type::COLS, A_Type::COLS,
+                                     _U_RowIndices, _U_RowPointers>
+      _U_triangular;
 };
 
 /* make LinalgSolverLU */
diff --git a/python_numpy/python_numpy_linalg_qr.hpp b/python_numpy/python_numpy_linalg_qr.hpp
index aa8f1cf..e3bc09e 100644
--- a/python_numpy/python_numpy_linalg_qr.hpp
+++ b/python_numpy/python_numpy_linalg_qr.hpp
@@ -20,9 +20,18 @@ template <typename T, std::size_t M, std::size_t N> class LinalgSolverQR {
   static_assert(std::is_same<T, double>::value || std::is_same<T, float>::value,
                 "Value data type must be float or double.");
 
+private:
+  /* Type */
+  using _R_TriangluarRowIndices = Base::Matrix::UpperTriangularRowIndices<M, N>;
+  using _R_TriangluarRowPointers =
+      Base::Matrix::UpperTriangularRowPointers<M, N>;
+
 public:
   /* Constructor */
-  LinalgSolverQR() {}
+  LinalgSolverQR()
+      : _QR_decomposer(),
+        _R_triangular(Base::Matrix::TriangularSparse<T, M, N>::create_upper()) {
+  }
 
   /* Copy Constructor */
   LinalgSolverQR(const LinalgSolverQR<T, M, N> &other)
@@ -56,19 +65,17 @@ template <typename T, std::size_t M, std::size_t N> class LinalgSolverQR {
   }
 
   /* Get Q, R */
-  inline auto get_R(void)
-      -> Matrix<DefSparse, T, M, N,
-                CreateSparseAvailableFromIndicesAndPointers<
-                    N, Base::Matrix::UpperTriangularRowIndices<M, N>,
-                    Base::Matrix::UpperTriangularRowPointers<M, N>>> const {
+  inline auto get_R(void) -> Matrix<
+      DefSparse, T, M, N,
+      CreateSparseAvailableFromIndicesAndPointers<
+          N, _R_TriangluarRowIndices, _R_TriangluarRowPointers>> const {
 
     Base::Matrix::TriangularSparse<T, M, N>::set_values_upper(
         this->_R_triangular, this->_QR_decomposer.get_R());
 
     return Matrix<DefSparse, T, M, N,
                   CreateSparseAvailableFromIndicesAndPointers<
-                      N, Base::Matrix::UpperTriangularRowIndices<M, N>,
-                      Base::Matrix::UpperTriangularRowPointers<M, N>>>(
+                      N, _R_TriangluarRowIndices, _R_TriangluarRowPointers>>(
         this->_R_triangular);
   }
 
@@ -91,16 +98,16 @@ template <typename T, std::size_t M, std::size_t N> class LinalgSolverQR {
 private:
   /* Properties */
   Base::Matrix::QRDecomposition<T, M, N> _QR_decomposer;
-  Base::Matrix::CompiledSparseMatrix<
-      T, M, N, Base::Matrix::UpperTriangularRowIndices<M, N>,
-      Base::Matrix::UpperTriangularRowPointers<M, N>>
-      _R_triangular = Base::Matrix::TriangularSparse<T, M, N>::create_upper();
+
+  Base::Matrix::CompiledSparseMatrix<T, M, N, _R_TriangluarRowIndices,
+                                     _R_TriangluarRowPointers>
+      _R_triangular;
 };
 
 template <typename T, std::size_t M> class LinalgSolverQRDiag {
 public:
   /* Constructor */
-  LinalgSolverQRDiag() {}
+  LinalgSolverQRDiag() : _R() {}
 
   /* Copy Constructor */
   LinalgSolverQRDiag(const LinalgSolverQRDiag<T, M> &other) : _R(other._R) {}
@@ -141,6 +148,18 @@ template <typename T, std::size_t M> class LinalgSolverQRDiag {
 
 template <typename T, std::size_t M, std::size_t N, typename SparseAvailable>
 class LinalgSolverQRSparse {
+public:
+  /* Type */
+  using Value_Type = T;
+  static_assert(std::is_same<T, double>::value || std::is_same<T, float>::value,
+                "Value data type must be float or double.");
+
+private:
+  /* Type */
+  using _R_TriangluarRowIndices = Base::Matrix::UpperTriangularRowIndices<M, N>;
+  using _R_TriangluarRowPointers =
+      Base::Matrix::UpperTriangularRowPointers<M, N>;
+
 public:
   /* Constructor */
   LinalgSolverQRSparse() {}
@@ -181,18 +200,17 @@ class LinalgSolverQRSparse {
     this->_QR_decomposer.solve(A.matrix);
   }
 
-  inline auto get_R(void)
-      -> Matrix<DefSparse, T, M, N,
-                CreateSparseAvailableFromIndicesAndPointers<
-                    N, Base::Matrix::UpperTriangularRowIndices<M, N>,
-                    Base::Matrix::UpperTriangularRowPointers<M, N>>> const {
+  inline auto get_R(void) -> Matrix<
+      DefSparse, T, M, N,
+      CreateSparseAvailableFromIndicesAndPointers<
+          N, _R_TriangluarRowIndices, _R_TriangluarRowPointers>> const {
 
     Base::Matrix::TriangularSparse<T, M, N>::set_values_upper(
         this->_R_triangular, this->_QR_decomposer.get_R());
 
     return Base::Matrix::CompiledSparseMatrix<
         T, M, N, Base::Matrix::UpperTriangularRowIndices<M, M>,
-        Base::Matrix::UpperTriangularRowPointers<M, N>>(this->_R_triangular);
+        _R_TriangluarRowPointers>(this->_R_triangular);
   }
 
   inline auto get_Q(void) -> Matrix<DefDense, T, M, M> const {
@@ -218,9 +236,8 @@ class LinalgSolverQRSparse {
       Base::Matrix::RowPointersFromSparseAvailable<SparseAvailable>>
       _QR_decomposer;
 
-  Base::Matrix::CompiledSparseMatrix<
-      T, M, N, Base::Matrix::UpperTriangularRowIndices<M, N>,
-      Base::Matrix::UpperTriangularRowPointers<M, N>>
+  Base::Matrix::CompiledSparseMatrix<T, M, N, _R_TriangluarRowIndices,
+                                     _R_TriangluarRowPointers>
       _R_triangular = Base::Matrix::TriangularSparse<T, M, N>::create_upper();
 };
 
diff --git a/python_numpy/python_numpy_linalg_solver.hpp b/python_numpy/python_numpy_linalg_solver.hpp
index 42c634e..37cb2c3 100644
--- a/python_numpy/python_numpy_linalg_solver.hpp
+++ b/python_numpy/python_numpy_linalg_solver.hpp
@@ -327,9 +327,8 @@ class LinalgSolver {
   /* Variable */
   Base::Matrix::Matrix<T, M, K> X_1;
 
-  Value_Type decay_rate = static_cast<Value_Type>(0);
-  Value_Type division_min =
-      static_cast<Value_Type>(DEFAULT_DIVISION_MIN_LINALG_SOLVER);
+  Value_Type decay_rate;
+  Value_Type division_min;
   std::array<Value_Type, K> rho;
   std::array<std::size_t, K> rep_num;
 };
@@ -344,7 +343,9 @@ template <typename T, std::size_t M> class LinalgInvDiag {
 
 public:
   /* Constructor */
-  LinalgInvDiag() {}
+  LinalgInvDiag()
+      : X_1(), division_min(static_cast<Value_Type>(
+                   DEFAULT_DIVISION_MIN_LINALG_SOLVER)) {}
 
   /* Copy Constructor */
   LinalgInvDiag(const LinalgInvDiag<T, M> &other)
@@ -398,8 +399,7 @@ template <typename T, std::size_t M> class LinalgInvDiag {
   /* Variable */
   Base::Matrix::DiagMatrix<T, M> X_1;
 
-  Value_Type division_min =
-      static_cast<Value_Type>(DEFAULT_DIVISION_MIN_LINALG_SOLVER);
+  Value_Type division_min;
 };
 
 /* make LinalgSolver for inv */
@@ -624,7 +624,11 @@ class LinalgLstsqSolver {
 
 public:
   /* Constructor */
-  LinalgLstsqSolver() {}
+  LinalgLstsqSolver()
+      : X_1(), decay_rate(static_cast<Value_Type>(0)),
+        division_min(
+            static_cast<Value_Type>(DEFAULT_DIVISION_MIN_LINALG_SOLVER)),
+        rho({}), rep_num({}) {}
 
   /* Copy Constructor */
   LinalgLstsqSolver(const LinalgLstsqSolver<T, M, N, K, SparseAvailable_A,
@@ -775,9 +779,8 @@ class LinalgLstsqSolver {
   /* Properties */
   Base::Matrix::Matrix<T, N, K> X_1;
 
-  Value_Type decay_rate = static_cast<Value_Type>(0);
-  Value_Type division_min =
-      static_cast<Value_Type>(DEFAULT_DIVISION_MIN_LINALG_SOLVER);
+  Value_Type decay_rate;
+  Value_Type division_min;
   std::array<Value_Type, K> rho;
   std::array<std::size_t, K> rep_num;
 };