diff --git a/.github/workflows/run_test_vs.yml b/.github/workflows/run_test_vs.yml
index c878193..0c7568f 100644
--- a/.github/workflows/run_test_vs.yml
+++ b/.github/workflows/run_test_vs.yml
@@ -13,9 +13,9 @@ jobs:
       matrix:
         define:
           - ""
-          - "-DBASE_MATRIX_USE_STD_VECTOR"
-          - "-DBASE_MATRIX_USE_FOR_LOOP_OPERATION"
-          - "-DBASE_MATRIX_USE_STD_VECTOR -DBASE_MATRIX_USE_FOR_LOOP_OPERATION"
+          - "-D__BASE_MATRIX_USE_STD_VECTOR__"
+          - "-D__BASE_MATRIX_USE_FOR_LOOP_OPERATION__"
+          - "-D__BASE_MATRIX_USE_STD_VECTOR__ -D__BASE_MATRIX_USE_FOR_LOOP_OPERATION__"
 
     steps:
     - name: Checkout code
diff --git a/base_matrix/base_matrix.hpp b/base_matrix/base_matrix.hpp
index 0c15c69..290ebc6 100644
--- a/base_matrix/base_matrix.hpp
+++ b/base_matrix/base_matrix.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_HPP
-#define BASE_MATRIX_HPP
+#ifndef __BASE_MATRIX_HPP__
+#define __BASE_MATRIX_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -20,4 +20,4 @@
 #include "base_matrix_variable_sparse.hpp"
 #include "base_matrix_vector.hpp"
 
-#endif // BASE_MATRIX_HPP
+#endif // __BASE_MATRIX_HPP__
diff --git a/base_matrix/base_matrix_cholesky_decomposition.hpp b/base_matrix/base_matrix_cholesky_decomposition.hpp
index 691dcd3..b8f7ac0 100644
--- a/base_matrix/base_matrix_cholesky_decomposition.hpp
+++ b/base_matrix/base_matrix_cholesky_decomposition.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_CHOLESKY_DECOMPOSITION_HPP
-#define BASE_MATRIX_CHOLESKY_DECOMPOSITION_HPP
+#ifndef __BASE_MATRIX_CHOLESKY_DECOMPOSITION_HPP__
+#define __BASE_MATRIX_CHOLESKY_DECOMPOSITION_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -164,4 +164,4 @@ inline Matrix<T, M, M> cholesky_decomposition_sparse(
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_CHOLESKY_DECOMPOSITION_HPP
+#endif // __BASE_MATRIX_CHOLESKY_DECOMPOSITION_HPP__
diff --git a/base_matrix/base_matrix_compiled_sparse.hpp b/base_matrix/base_matrix_compiled_sparse.hpp
index 12d2c38..6eff3c0 100644
--- a/base_matrix/base_matrix_compiled_sparse.hpp
+++ b/base_matrix/base_matrix_compiled_sparse.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_COMPILED_SPARSE_HPP
-#define BASE_MATRIX_COMPILED_SPARSE_HPP
+#ifndef __BASE_MATRIX_COMPILED_SPARSE_HPP__
+#define __BASE_MATRIX_COMPILED_SPARSE_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -23,7 +23,7 @@ template <typename T, std::size_t M, std::size_t N, typename RowIndices,
           typename RowPointers>
 class CompiledSparseMatrix {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   CompiledSparseMatrix() : values(RowPointers::list[M], static_cast<T>(0)) {}
 
@@ -32,7 +32,7 @@ class CompiledSparseMatrix {
 
   CompiledSparseMatrix(const std::vector<T> &values) : values(values) {}
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   CompiledSparseMatrix() : values{} {}
 
@@ -53,7 +53,7 @@ class CompiledSparseMatrix {
     std::copy(values.begin(), values.end(), this->values.begin());
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   CompiledSparseMatrix(
@@ -82,11 +82,11 @@ class CompiledSparseMatrix {
   }
 
   /* Variable */
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> values;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, RowPointers::list[M]> values;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 };
 
 /* Output dense matrix */
@@ -171,7 +171,7 @@ inline Matrix<T, M, N> output_dense_matrix(
     const CompiledSparseMatrix<T, M, N, RowIndices, RowPointers> &mat) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; j++) {
     for (std::size_t k = RowPointers::list[j]; k < RowPointers::list[j + 1];
@@ -180,12 +180,12 @@ inline Matrix<T, M, N> output_dense_matrix(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_OUTPUT_DENSE_MATRIX<T, M, N, RowIndices,
                                                     RowPointers>(mat, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -273,7 +273,7 @@ inline Matrix<T, N, M> output_matrix_transpose(
     const CompiledSparseMatrix<T, M, N, RowIndices, RowPointers> &mat) {
   Matrix<T, N, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; j++) {
     for (std::size_t k = RowPointers::list[j]; k < RowPointers::list[j + 1];
@@ -282,13 +282,13 @@ inline Matrix<T, N, M> output_matrix_transpose(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_TRANSPOSE_DENSE_MATRIX<T, M, N, RowIndices,
                                                        RowPointers>(mat,
                                                                     result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -363,7 +363,7 @@ inline auto create_compiled_sparse(const Matrix<T, M, N> &A)
                        DenseMatrixRowPointers<M, N>>
       Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t consecutive_index = 0;
   for (std::size_t i = 0; i < M; i++) {
@@ -373,12 +373,12 @@ inline auto create_compiled_sparse(const Matrix<T, M, N> &A)
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DENSE_MATRIX_SUBSTITUTE_SPARSE<
       T, M, N, DenseMatrixRowIndices<M, N>, DenseMatrixRowPointers<M, N>>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -599,7 +599,7 @@ inline void set_sparse_matrix_value(
   static_assert(ColumnToSet < M, "Column number must be less than M");
   static_assert(RowToSet < N, "Row number must be less than N");
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     if (ColumnToSet == j) {
@@ -614,13 +614,13 @@ inline void set_sparse_matrix_value(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_SET_MATRIX_VALUE<ColumnToSet, RowToSet, T, M, N,
                                                  RowIndices_A, RowPointers_A>(
       A, value);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 /* Get Sparse Matrix Value */
@@ -796,7 +796,7 @@ inline T get_sparse_matrix_value(
 
   T value = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     if (ColumnToGet == j) {
@@ -811,13 +811,13 @@ inline T get_sparse_matrix_value(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_GET_MATRIX_VALUE<ColumnToGet, RowToGet, T, M, N,
                                                  RowIndices_A, RowPointers_A>(
       A, value);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return value;
 }
@@ -825,4 +825,4 @@ inline T get_sparse_matrix_value(
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_COMPILED_SPARSE_HPP
+#endif // __BASE_MATRIX_COMPILED_SPARSE_HPP__
diff --git a/base_matrix/base_matrix_compiled_sparse_operation.hpp b/base_matrix/base_matrix_compiled_sparse_operation.hpp
index 97950b4..5808dba 100644
--- a/base_matrix/base_matrix_compiled_sparse_operation.hpp
+++ b/base_matrix/base_matrix_compiled_sparse_operation.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_COMPILED_SPARSE_OPERATION_HPP
-#define BASE_MATRIX_COMPILED_SPARSE_OPERATION_HPP
+#ifndef __BASE_MATRIX_COMPILED_SPARSE_OPERATION_HPP__
+#define __BASE_MATRIX_COMPILED_SPARSE_OPERATION_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -135,7 +135,7 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
           const Matrix<T, N, K> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < K; i++) {
     for (std::size_t j = 0; j < M; j++) {
@@ -148,13 +148,13 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_DENSE<T, M, N, RowIndices_A,
                                                       RowPointers_A, K>(A, B,
                                                                         Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -283,7 +283,7 @@ operator*(const Matrix<T, M, N> &A,
           const CompiledSparseMatrix<T, N, K, RowIndices_B, RowPointers_B> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < N; j++) {
     for (std::size_t k = RowPointers_B::list[j]; k < RowPointers_B::list[j + 1];
@@ -294,13 +294,13 @@ operator*(const Matrix<T, M, N> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DENSE_MATRIX_MULTIPLY_SPARSE<T, M, N, RowIndices_B,
                                                       RowPointers_B, K>(A, B,
                                                                         Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -378,7 +378,7 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
           const Matrix<T, M, N> &B) {
   Matrix<T, M, N> Y = B;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = RowPointers_A::list[j]; k < RowPointers_A::list[j + 1];
@@ -387,12 +387,12 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_DENSE<T, M, N, RowIndices_A,
                                                  RowPointers_A>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -405,7 +405,7 @@ operator+(const Matrix<T, M, N> &B,
           const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A) {
   Matrix<T, M, N> Y = B;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = RowPointers_A::list[j]; k < RowPointers_A::list[j + 1];
@@ -414,12 +414,12 @@ operator+(const Matrix<T, M, N> &B,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_DENSE<T, M, N, RowIndices_A,
                                                  RowPointers_A>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -558,7 +558,7 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
 
   CompiledSparseMatrix<T, M, M, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, M> Y_temp = Base::Matrix::output_dense_matrix(B);
 
@@ -576,7 +576,7 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::SET_DIAG_MATRIX_VALUES_TO_SPARSE_MATRIX<T, M, N, RowIndices_Y,
                                                         RowPointers_Y>(Y, B);
@@ -584,7 +584,7 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, RowIndices_Y, RowPointers_Y>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -618,7 +618,7 @@ operator+(const DiagMatrix<T, M> &B,
 
   CompiledSparseMatrix<T, M, M, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, M> Y_temp = Base::Matrix::output_dense_matrix(B);
 
@@ -636,7 +636,7 @@ operator+(const DiagMatrix<T, M> &B,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::SET_DIAG_MATRIX_VALUES_TO_SPARSE_MATRIX<T, M, N, RowIndices_Y,
                                                         RowPointers_Y>(Y, B);
@@ -644,7 +644,7 @@ operator+(const DiagMatrix<T, M> &B,
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, RowIndices_Y, RowPointers_Y>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -681,7 +681,7 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
 
   CompiledSparseMatrix<T, M, N, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, M> Y_temp = Base::Matrix::output_dense_matrix(B);
 
@@ -699,14 +699,14 @@ operator+(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, RowIndices_Y, RowPointers_Y>(A, Y);
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_SPARSE<
       T, M, N, RowIndices_B, RowPointers_B, RowIndices_Y, RowPointers_Y>(B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -719,7 +719,7 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
           const Matrix<T, M, N> &B) {
   Matrix<T, M, N> Y = -B;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = RowPointers_A::list[j]; k < RowPointers_A::list[j + 1];
@@ -728,12 +728,12 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_DENSE<T, M, N, RowIndices_A,
                                                  RowPointers_A>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -811,7 +811,7 @@ operator-(const Matrix<T, M, N> &B,
           const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A) {
   Matrix<T, M, N> Y = B;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = RowPointers_A::list[j]; k < RowPointers_A::list[j + 1];
@@ -820,12 +820,12 @@ operator-(const Matrix<T, M, N> &B,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_SUB_DENSE<T, M, N, RowIndices_A,
                                                  RowPointers_A>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -859,7 +859,7 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
 
   CompiledSparseMatrix<T, M, M, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, M> Y_temp = -(Base::Matrix::output_dense_matrix(B));
 
@@ -877,7 +877,7 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::SET_DIAG_MATRIX_VALUES_TO_SPARSE_MATRIX<T, M, N, RowIndices_Y,
                                                         RowPointers_Y>(Y, -B);
@@ -885,7 +885,7 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, RowIndices_Y, RowPointers_Y>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -990,7 +990,7 @@ operator-(const DiagMatrix<T, M> &B,
 
   CompiledSparseMatrix<T, M, M, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, M> Y_temp = Base::Matrix::output_dense_matrix(B);
 
@@ -1008,7 +1008,7 @@ operator-(const DiagMatrix<T, M> &B,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::SET_DIAG_MATRIX_VALUES_TO_SPARSE_MATRIX<T, M, N, RowIndices_Y,
                                                         RowPointers_Y>(Y, B);
@@ -1016,7 +1016,7 @@ operator-(const DiagMatrix<T, M> &B,
   Base::Matrix::COMPILED_SPARSE_MATRIX_SUB_DIAG<T, M, N, RowIndices_A,
                                                 RowPointers_A>(A, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -1125,7 +1125,7 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
 
   CompiledSparseMatrix<T, M, N, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, M> Y_temp = Base::Matrix::output_dense_matrix(A);
 
@@ -1143,14 +1143,14 @@ operator-(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_ADD_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, RowIndices_Y, RowPointers_Y>(A, Y);
   Base::Matrix::COMPILED_SPARSE_MATRIX_SUB_SPARSE<
       T, M, N, RowIndices_B, RowPointers_B, RowIndices_Y, RowPointers_Y>(B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -1203,19 +1203,19 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
           const T &scalar) {
   CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> Y = A;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < RowIndices_A::size; i++) {
     Y.values[i] = scalar * A.values[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_SCALAR<T, M, N, RowIndices_A,
                                                        RowPointers_A>(A, scalar,
                                                                       Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -1228,19 +1228,19 @@ operator*(const T &scalar,
           const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A) {
   CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> Y = A;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < RowIndices_A::size; i++) {
     Y.values[i] = scalar * A.values[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_SCALAR<T, M, N, RowIndices_A,
                                                        RowPointers_A>(A, scalar,
                                                                       Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -1333,7 +1333,7 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
           const Vector<T, N> &b) {
   Vector<T, M> y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; j++) {
     T sum = static_cast<T>(0);
@@ -1344,12 +1344,12 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     y[j] = sum;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_VECTOR<T, M, N, RowIndices_A,
                                                        RowPointers_A>(A, b, y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return y;
 }
@@ -1433,7 +1433,7 @@ inline ColVector<T, K> colVector_a_mul_SparseB(
     const CompiledSparseMatrix<T, N, K, RowIndices_B, RowPointers_B> &B) {
   ColVector<T, K> y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < N; j++) {
     for (std::size_t k = RowPointers_B::list[j]; k < RowPointers_B::list[j + 1];
@@ -1442,12 +1442,12 @@ inline ColVector<T, K> colVector_a_mul_SparseB(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_COLVECTOR_MULTIPLY_SPARSE<T, N, K, RowIndices_B,
                                                    RowPointers_B>(a, B, y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return y;
 }
@@ -1582,7 +1582,7 @@ inline Matrix<T, M, K> matrix_multiply_SparseA_mul_BTranspose(
     const Matrix<T, K, N> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < K; i++) {
     for (std::size_t j = 0; j < M; j++) {
@@ -1595,12 +1595,12 @@ inline Matrix<T, M, K> matrix_multiply_SparseA_mul_BTranspose(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_DENSE_TRANSPOSE<
       T, M, N, RowIndices_A, RowPointers_A, K>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -1798,7 +1798,7 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
 
   CompiledSparseMatrix<T, M, K, RowIndices_Y, RowPointers_Y> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Matrix<T, M, K> Y_temp;
 
@@ -1819,13 +1819,13 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, K, RowIndices_B, RowPointers_B,
       RowIndices_Y, RowPointers_Y>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -1993,7 +1993,7 @@ inline Matrix<T, M, K> matrix_multiply_SparseATranspose_mul_SparseB(
     const CompiledSparseMatrix<T, N, K, RowIndices_B, RowPointers_B> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; i++) {
     for (std::size_t k = RowPointers_A::list[i]; k < RowPointers_A::list[i + 1];
@@ -2006,13 +2006,13 @@ inline Matrix<T, M, K> matrix_multiply_SparseATranspose_mul_SparseB(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_TRANSPOSE_MULTIPLY_SPARSE<
       T, M, N, RowIndices_A, RowPointers_A, K, RowIndices_B, RowPointers_B>(
       A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -2240,7 +2240,7 @@ inline Matrix<T, M, K> matrix_multiply_SparseA_mul_SparseBTranspose(
     const CompiledSparseMatrix<T, K, N, RowIndices_B, RowPointers_B> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; i++) {
     for (std::size_t j = 0; j < K; j++) {
@@ -2256,13 +2256,13 @@ inline Matrix<T, M, K> matrix_multiply_SparseA_mul_SparseBTranspose(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_SPARSE_TRANSPOSE<
       T, M, N, RowIndices_A, RowPointers_A, K, RowIndices_B, RowPointers_B>(
       A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -2348,7 +2348,7 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
 
   CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; j++) {
     for (std::size_t k = RowPointers_A::list[j]; k < RowPointers_A::list[j + 1];
@@ -2357,12 +2357,12 @@ operator*(const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_MATRIX_MULTIPLY_DIAG<T, M, N, RowIndices_A,
                                                      RowPointers_A>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -2448,7 +2448,7 @@ operator*(const DiagMatrix<T, M> &A,
 
   CompiledSparseMatrix<T, M, K, RowIndices_B, RowPointers_B> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; j++) {
     for (std::size_t k = RowPointers_B::list[j]; k < RowPointers_B::list[j + 1];
@@ -2457,12 +2457,12 @@ operator*(const DiagMatrix<T, M> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::DIAG_MULTIPLY_COMPILED_SPARSE_MATRIX<T, M, K, RowIndices_B,
                                                      RowPointers_B>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -2591,7 +2591,7 @@ inline Matrix<T, K, M> matrix_multiply_Transpose_DiagA_mul_SparseB(
     const CompiledSparseMatrix<T, M, K, RowIndices_B, RowPointers_B> &B) {
   Matrix<T, K, M> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; j++) {
     for (std::size_t k = RowPointers_B::list[j]; k < RowPointers_B::list[j + 1];
@@ -2604,12 +2604,12 @@ inline Matrix<T, K, M> matrix_multiply_Transpose_DiagA_mul_SparseB(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_TRANSPOSE_DIAG_MATRIX_MULTIPLY_SPARSE<
       T, M, K, RowIndices_B, RowPointers_B>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -2752,7 +2752,7 @@ inline Matrix<T, N, K> matrix_multiply_A_mul_SparseBTranspose(
     const CompiledSparseMatrix<T, M, K, RowIndices_B, RowPointers_B> &B) {
   Matrix<T, N, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     for (std::size_t j = 0; j < K; ++j) {
@@ -2765,12 +2765,12 @@ inline Matrix<T, N, K> matrix_multiply_A_mul_SparseBTranspose(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DENSE_MATRIX_MULTIPLY_SPARSE_TRANSPOSE<
       T, M, N, RowIndices_B, RowPointers_B, K>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -2897,7 +2897,7 @@ inline Matrix<T, M, K> matrix_multiply_ATranspose_mul_SparseB(
     const CompiledSparseMatrix<T, N, K, RowIndices_B, RowPointers_B> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < N; j++) {
     for (std::size_t k = RowPointers_B::list[j]; k < RowPointers_B::list[j + 1];
@@ -2908,12 +2908,12 @@ inline Matrix<T, M, K> matrix_multiply_ATranspose_mul_SparseB(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DENSE_TRANSPOSE_MATRIX_MULTIPLY_SPARSE<
       T, M, N, K, RowIndices_B, RowPointers_B>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -3046,7 +3046,7 @@ inline Matrix<T, M, K> matrix_multiply_SparseAT_mul_B(
     const Matrix<T, N, K> &B) {
   Matrix<T, M, K> Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < N; j++) {
     for (std::size_t k = RowPointers_A::list[j]; k < RowPointers_A::list[j + 1];
@@ -3057,12 +3057,12 @@ inline Matrix<T, M, K> matrix_multiply_SparseAT_mul_B(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_TRANSPOSE_MATRIX_MULTIPLY_DENSE<
       T, N, M, RowIndices_A, RowPointers_A, K>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Y;
 }
@@ -3070,4 +3070,4 @@ inline Matrix<T, M, K> matrix_multiply_SparseAT_mul_B(
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_COMPILED_SPARSE_OPERATION_HPP
+#endif // __BASE_MATRIX_COMPILED_SPARSE_OPERATION_HPP__
diff --git a/base_matrix/base_matrix_complex.hpp b/base_matrix/base_matrix_complex.hpp
index d486c30..17451d7 100644
--- a/base_matrix/base_matrix_complex.hpp
+++ b/base_matrix/base_matrix_complex.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_COMPLEX_HPP
-#define BASE_MATRIX_COMPLEX_HPP
+#ifndef __BASE_MATRIX_COMPLEX_HPP__
+#define __BASE_MATRIX_COMPLEX_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -286,4 +286,4 @@ inline Complex<T> complex_sign(const Complex<T> &a_comp, T division_min) {
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_COMPLEX_HPP
+#endif // __BASE_MATRIX_COMPLEX_HPP__
diff --git a/base_matrix/base_matrix_concatenate.hpp b/base_matrix/base_matrix_concatenate.hpp
index 47cbd4b..ccf0255 100644
--- a/base_matrix/base_matrix_concatenate.hpp
+++ b/base_matrix/base_matrix_concatenate.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_CONCATENATE_HPP
-#define BASE_MATRIX_CONCATENATE_HPP
+#ifndef __BASE_MATRIX_CONCATENATE_HPP__
+#define __BASE_MATRIX_CONCATENATE_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -52,18 +52,18 @@ inline void update_vertically_concatenated_matrix(Matrix<T, M + P, N> &Y,
                                                   const Matrix<T, M, N> &A,
                                                   const Matrix<T, P, N> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t row = 0; row < N; row++) {
     Base::Utility::copy<T, 0, M, 0, M, (M + P)>(A.data[row], Y.data[row]);
     Base::Utility::copy<T, 0, P, M, M, (M + P)>(B.data[row], Y.data[row]);
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_VERTICAL_CONCATENATE<T, M, N, P>(A, B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, std::size_t P>
@@ -538,7 +538,7 @@ inline void update_horizontally_concatenated_matrix(Matrix<T, M, N + P> &Y,
                                                     const Matrix<T, M, N> &A,
                                                     const Matrix<T, M, P> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t row = 0; row < N; row++) {
     std::copy(A(row).begin(), A(row).end(), Y(row).begin());
@@ -550,12 +550,12 @@ inline void update_horizontally_concatenated_matrix(Matrix<T, M, N + P> &Y,
     B_row++;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SPARSE_HORIZONTAL_CONCATENATE_1<T, M, N, P>(A, Y);
   Base::Matrix::COMPILED_SPARSE_HORIZONTAL_CONCATENATE_2<T, M, N, P>(B, Y);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, std::size_t P>
@@ -680,7 +680,7 @@ inline void update_horizontally_concatenated_matrix(
             DenseAvailable<M, N>, DiagAvailable<M>>>> &Y,
     const Matrix<T, M, N> &A, const DiagMatrix<T, M> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   for (std::size_t i = 0; i < M; i++) {
@@ -701,7 +701,7 @@ inline void update_horizontally_concatenated_matrix(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -716,7 +716,7 @@ inline void update_horizontally_concatenated_matrix(
   ConcatMatrixSetFromDiagRow<T, M, M, (M + N), 0, N, RowIndices_Y,
                              RowPointers_Y, M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N>
@@ -830,7 +830,7 @@ inline void update_horizontally_concatenated_matrix(
     const Matrix<T, M, N> &A,
     const CompiledSparseMatrix<T, M, L, RowIndices_B, RowPointers_B> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   std::size_t sparse_value_count = 0;
@@ -858,7 +858,7 @@ inline void update_horizontally_concatenated_matrix(
     sparse_col_count = 0;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -876,7 +876,7 @@ inline void update_horizontally_concatenated_matrix(
                                0, N, RowIndices_Y, RowPointers_Y,
                                M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, std::size_t L,
@@ -918,7 +918,7 @@ inline void update_horizontally_concatenated_matrix(
             DiagAvailable<M>, DenseAvailable<M, N>>>> &Y,
     const DiagMatrix<T, M> &A, const Matrix<T, M, N> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   for (std::size_t i = 0; i < M; i++) {
@@ -938,7 +938,7 @@ inline void update_horizontally_concatenated_matrix(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -953,7 +953,7 @@ inline void update_horizontally_concatenated_matrix(
   ConcatMatrixSetFromDenseRow<T, M, N, M, (M + N), 0, M, RowIndices_Y,
                               RowPointers_Y, M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N>
@@ -989,7 +989,7 @@ inline void update_horizontally_concatenated_matrix(
             DiagAvailable<M>, DiagAvailable<M>>>> &Y,
     const DiagMatrix<T, M> &A, const DiagMatrix<T, M> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   for (std::size_t i = 0; i < M; i++) {
@@ -1010,7 +1010,7 @@ inline void update_horizontally_concatenated_matrix(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -1025,7 +1025,7 @@ inline void update_horizontally_concatenated_matrix(
   ConcatMatrixSetFromDiagRow<T, M, M, (2 * M), 0, M, RowIndices_Y,
                              RowPointers_Y, M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M>
@@ -1065,7 +1065,7 @@ inline void update_horizontally_concatenated_matrix(
     const DiagMatrix<T, M> &A,
     const CompiledSparseMatrix<T, M, N, RowIndices_B, RowPointers_B> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   std::size_t sparse_value_count = 0;
@@ -1094,7 +1094,7 @@ inline void update_horizontally_concatenated_matrix(
     sparse_col_count = 0;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -1112,7 +1112,7 @@ inline void update_horizontally_concatenated_matrix(
                                0, M, RowIndices_Y, RowPointers_Y,
                                M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, typename RowIndices_B,
@@ -1160,7 +1160,7 @@ inline void update_horizontally_concatenated_matrix(
     const CompiledSparseMatrix<T, M, L, RowIndices_A, RowPointers_A> &A,
     const Matrix<T, M, N> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   std::size_t sparse_value_count = 0;
@@ -1190,7 +1190,7 @@ inline void update_horizontally_concatenated_matrix(
     sparse_col_count = 0;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -1211,7 +1211,7 @@ inline void update_horizontally_concatenated_matrix(
   ConcatMatrixSetFromDenseRow<T, M, N, M, (N + L), 0, N, RowIndices_Y,
                               RowPointers_Y, M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, std::size_t L,
@@ -1263,7 +1263,7 @@ inline void update_horizontally_concatenated_matrix(
     const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     const DiagMatrix<T, M> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   std::size_t sparse_value_count = 0;
@@ -1296,7 +1296,7 @@ inline void update_horizontally_concatenated_matrix(
     sparse_col_count = 0;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -1316,7 +1316,7 @@ inline void update_horizontally_concatenated_matrix(
   ConcatMatrixSetFromDiagRow<T, M, M, (M + N), 0, N, RowIndices_Y,
                              RowPointers_Y, M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, typename RowIndices_A,
@@ -1371,7 +1371,7 @@ inline void update_horizontally_concatenated_matrix(
     const CompiledSparseMatrix<T, M, N, RowIndices_A, RowPointers_A> &A,
     const CompiledSparseMatrix<T, M, L, RowIndices_B, RowPointers_B> &B) {
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   std::size_t value_count = 0;
   std::size_t sparse_value_count_A = 0;
@@ -1410,7 +1410,7 @@ inline void update_horizontally_concatenated_matrix(
     sparse_col_count_B = 0;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   using RowIndices_Y =
       RowIndicesFromSparseAvailable<ConcatenateSparseAvailableHorizontally<
@@ -1433,7 +1433,7 @@ inline void update_horizontally_concatenated_matrix(
                                0, N, RowIndices_Y, RowPointers_Y,
                                M - 1>::compute(Y, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t M, std::size_t N, std::size_t L,
@@ -1477,4 +1477,4 @@ inline auto concatenate_horizontally(
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_CONCATENATE_HPP
+#endif // __BASE_MATRIX_CONCATENATE_HPP__
diff --git a/base_matrix/base_matrix_diagonal.hpp b/base_matrix/base_matrix_diagonal.hpp
index 714054b..16e7f61 100644
--- a/base_matrix/base_matrix_diagonal.hpp
+++ b/base_matrix/base_matrix_diagonal.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_DIAGONAL_HPP
-#define BASE_MATRIX_DIAGONAL_HPP
+#ifndef __BASE_MATRIX_DIAGONAL_HPP__
+#define __BASE_MATRIX_DIAGONAL_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -17,7 +17,7 @@ namespace Matrix {
 
 template <typename T, std::size_t M> class DiagMatrix {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   DiagMatrix() : data(M, static_cast<T>(0)) {}
 
@@ -32,7 +32,7 @@ template <typename T, std::size_t M> class DiagMatrix {
     }
   }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   DiagMatrix() : data{} {}
 
@@ -57,7 +57,7 @@ template <typename T, std::size_t M> class DiagMatrix {
     }
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   DiagMatrix(const DiagMatrix<T, M> &other) : data(other.data) {}
@@ -117,11 +117,11 @@ template <typename T, std::size_t M> class DiagMatrix {
   }
 
 /* Variable */
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> data;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, M> data;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 };
 
 /* Matrix Addition */
@@ -155,17 +155,17 @@ inline DiagMatrix<T, M> operator+(const DiagMatrix<T, M> &A,
                                   const DiagMatrix<T, M> &B) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     result[j] = A[j] + B[j];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_ADDER<T, M>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -197,17 +197,17 @@ inline Matrix<T, M, M> operator+(const DiagMatrix<T, M> &A,
                                  const Matrix<T, M, M> &B) {
   Matrix<T, M, M> result = B;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result(i, i) += A[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_ADD_MATRIX<T, M>(A, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -217,17 +217,17 @@ inline Matrix<T, M, M> operator+(const Matrix<T, M, M> &A,
                                  const DiagMatrix<T, M> &B) {
   Matrix<T, M, M> result = A;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result(i, i) += B[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_ADD_MATRIX<T, M>(A, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -259,17 +259,17 @@ template <typename T, std::size_t M>
 inline DiagMatrix<T, M> operator-(const DiagMatrix<T, M> &A) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result[i] = -A[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_MINUS_DIAG_MATRIX<T, M>(A, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -305,17 +305,17 @@ inline DiagMatrix<T, M> operator-(const DiagMatrix<T, M> &A,
                                   const DiagMatrix<T, M> &B) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     result[j] = A[j] - B[j];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_SUBTRACTOR<T, M>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -347,17 +347,17 @@ inline Matrix<T, M, M> operator-(const DiagMatrix<T, M> &A,
                                  const Matrix<T, M, M> &B) {
   Matrix<T, M, M> result = -B;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result(i, i) += A[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_SUB_MATRIX<T, M>(A, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -389,17 +389,17 @@ inline Matrix<T, M, M> operator-(const Matrix<T, M, M> &A,
                                  const DiagMatrix<T, M> &B) {
   Matrix<T, M, M> result = A;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result(i, i) -= B[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_SUB_DIAG_MATRIX<T, M>(B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -434,17 +434,17 @@ template <typename T, std::size_t M>
 inline DiagMatrix<T, M> operator*(const DiagMatrix<T, M> &A, const T &scalar) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result[i] = A[i] * scalar;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_MULTIPLY_SCALAR<T, M>(A, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -453,17 +453,17 @@ template <typename T, std::size_t M>
 inline DiagMatrix<T, M> operator*(const T &scalar, const DiagMatrix<T, M> &A) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result[i] = A[i] * scalar;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_MULTIPLY_SCALAR<T, M>(A, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -499,17 +499,17 @@ inline Vector<T, M> operator*(const DiagMatrix<T, M> &A,
                               const Vector<T, M> &vec) {
   Vector<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     result[i] = A[i] * vec[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_MULTIPLY_VECTOR<T, M>(A, vec, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -547,17 +547,17 @@ inline DiagMatrix<T, M> operator*(const DiagMatrix<T, M> &A,
                                   const DiagMatrix<T, M> &B) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     result[j] = A[j] * B[j];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_MULTIPLY_DIAG<T, M>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -615,7 +615,7 @@ inline Matrix<T, M, N> operator*(const DiagMatrix<T, M> &A,
                                  const Matrix<T, M, N> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = 0; k < N; ++k) {
@@ -623,11 +623,11 @@ inline Matrix<T, M, N> operator*(const DiagMatrix<T, M> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_MULTIPLY_MATRIX<T, M, N>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -684,7 +684,7 @@ inline Matrix<T, L, M> operator*(const Matrix<T, L, M> &A,
                                  const DiagMatrix<T, M> &B) {
   Matrix<T, L, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < L; ++j) {
     for (std::size_t k = 0; k < M; ++k) {
@@ -692,11 +692,11 @@ inline Matrix<T, L, M> operator*(const Matrix<T, L, M> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_MULTIPLY_DIAG_MATRIX<T, L, M>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -724,17 +724,17 @@ template <typename T, std::size_t M>
 inline T output_trace(const DiagMatrix<T, M> &A) {
   T trace = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; i++) {
     trace += A[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   trace = Base::Matrix::COMPILED_DIAG_TRACE_CALCULATOR<T, M>(A);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return trace;
 }
@@ -766,17 +766,17 @@ template <typename T, std::size_t M>
 inline Matrix<T, M, M> output_dense_matrix(const DiagMatrix<T, M> &A) {
   Matrix<T, M, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; i++) {
     result(i, i) = A[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_TO_DENSE<T, M>(A, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -815,17 +815,17 @@ inline DiagMatrix<T, M> diag_divide_diag(const DiagMatrix<T, M> &A,
                                          const T division_min) {
   DiagMatrix<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     result[j] = A[j] / Base::Utility::avoid_zero_divide(B[j], division_min);
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_MATRIX_DIVIDER<T, M>(A, B, result, division_min);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -890,7 +890,7 @@ inline Matrix<T, M, N> diag_inv_multiply_dense(const DiagMatrix<T, M> &A,
                                                const T division_min) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = 0; k < N; ++k) {
@@ -899,12 +899,12 @@ inline Matrix<T, M, N> diag_inv_multiply_dense(const DiagMatrix<T, M> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_DIAG_INV_MULTIPLY_DENSE<T, M, N>(A, B, result,
                                                           division_min);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -912,4 +912,4 @@ inline Matrix<T, M, N> diag_inv_multiply_dense(const DiagMatrix<T, M> &A,
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_DIAGONAL_HPP
+#endif // __BASE_MATRIX_DIAGONAL_HPP__
diff --git a/base_matrix/base_matrix_eigen_solver.hpp b/base_matrix/base_matrix_eigen_solver.hpp
index 755da42..594ba24 100644
--- a/base_matrix/base_matrix_eigen_solver.hpp
+++ b/base_matrix/base_matrix_eigen_solver.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_EIGEN_SOLVER_HPP
-#define BASE_MATRIX_EIGEN_SOLVER_HPP
+#ifndef __BASE_MATRIX_EIGEN_SOLVER_HPP__
+#define __BASE_MATRIX_EIGEN_SOLVER_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -24,7 +24,7 @@ const double EIGEN_SMALL_VALUE = 1.0e-6;
 
 template <typename T, std::size_t M> class EigenSolverReal {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   EigenSolverReal()
       : iteration_max(0), _eigen_values(M, static_cast<T>(0)),
@@ -40,7 +40,7 @@ template <typename T, std::size_t M> class EigenSolverReal {
     this->_solve_values_with_qr_method(matrix);
   }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   EigenSolverReal()
       : iteration_max(0), _eigen_values{}, _division_min(static_cast<T>(0)),
@@ -55,7 +55,7 @@ template <typename T, std::size_t M> class EigenSolverReal {
     this->_solve_values_with_qr_method(matrix);
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   EigenSolverReal(EigenSolverReal<T, M> &other)
@@ -130,11 +130,11 @@ template <typename T, std::size_t M> class EigenSolverReal {
     this->_solve_vectors_with_inverse_iteration_method(matrix);
   }
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> get_eigen_values(void) { return this->_eigen_values; }
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, M> get_eigen_values(void) { return this->_eigen_values; }
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   Matrix<T, M, M> get_eigen_vectors(void) { return this->_eigen_vectors; }
 
@@ -144,11 +144,11 @@ template <typename T, std::size_t M> class EigenSolverReal {
 private:
   VariableSparseMatrix<T, M, M> _House;
   Matrix<T, M, M> _Hessen;
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> _eigen_values;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, M> _eigen_values;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
   T _division_min;
   Matrix<T, M, M> _eigen_vectors;
   T _small_value = static_cast<T>(EIGEN_SMALL_VALUE);
@@ -390,7 +390,7 @@ template <typename T, std::size_t M> class EigenSolverReal {
 
 template <typename T, std::size_t M> class EigenSolverComplex {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   EigenSolverComplex()
       : iteration_max(0), iteration_max_for_eigen_vector(0),
@@ -408,7 +408,7 @@ template <typename T, std::size_t M> class EigenSolverComplex {
     this->_solve_with_qr_method(matrix);
   }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   EigenSolverComplex()
       : iteration_max(0), iteration_max_for_eigen_vector(0), _eigen_values{},
@@ -426,7 +426,7 @@ template <typename T, std::size_t M> class EigenSolverComplex {
     this->_solve_with_qr_method(matrix);
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   EigenSolverComplex(EigenSolverComplex<T, M> &other)
@@ -507,13 +507,13 @@ template <typename T, std::size_t M> class EigenSolverComplex {
     this->_solve_vectors_with_inverse_iteration_method(matrix);
   }
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<Complex<T>> get_eigen_values(void) { return this->_eigen_values; }
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<Complex<T>, M> get_eigen_values(void) {
     return this->_eigen_values;
   }
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   Matrix<Complex<T>, M, M> get_eigen_vectors(void) {
     return this->_eigen_vectors;
@@ -527,11 +527,11 @@ template <typename T, std::size_t M> class EigenSolverComplex {
   VariableSparseMatrix<T, M, M> _House;
   VariableSparseMatrix<Complex<T>, M, M> _House_comp;
   Matrix<Complex<T>, M, M> _Hessen;
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<Complex<T>> _eigen_values;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<Complex<T>, M> _eigen_values;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
   T _division_min;
   Matrix<Complex<T>, M, M> _eigen_vectors;
   T _small_value = static_cast<T>(EIGEN_SMALL_VALUE);
@@ -785,4 +785,4 @@ template <typename T, std::size_t M> class EigenSolverComplex {
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_EIGEN_SOLVER_HPP
+#endif // __BASE_MATRIX_EIGEN_SOLVER_HPP__
diff --git a/base_matrix/base_matrix_inverse.hpp b/base_matrix/base_matrix_inverse.hpp
index 8f093d3..0d292e2 100644
--- a/base_matrix/base_matrix_inverse.hpp
+++ b/base_matrix/base_matrix_inverse.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_INVERSE_HPP
-#define BASE_MATRIX_INVERSE_HPP
+#ifndef __BASE_MATRIX_INVERSE_HPP__
+#define __BASE_MATRIX_INVERSE_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -752,4 +752,4 @@ inline Vector<Complex<T>, M> complex_gmres_k(const Matrix<Complex<T>, M, M> &A,
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_INVERSE_HPP
+#endif // __BASE_MATRIX_INVERSE_HPP__
diff --git a/base_matrix/base_matrix_lu_decomposition.hpp b/base_matrix/base_matrix_lu_decomposition.hpp
index 42cb5cc..803b261 100644
--- a/base_matrix/base_matrix_lu_decomposition.hpp
+++ b/base_matrix/base_matrix_lu_decomposition.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_LU_DECOMPOSITION_HPP
-#define BASE_MATRIX_LU_DECOMPOSITION_HPP
+#ifndef __BASE_MATRIX_LU_DECOMPOSITION_HPP__
+#define __BASE_MATRIX_LU_DECOMPOSITION_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -163,4 +163,4 @@ template <typename T, std::size_t M> class LUDecomposition {
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_LU_DECOMPOSITION_HPP
+#endif // __BASE_MATRIX_LU_DECOMPOSITION_HPP__
diff --git a/base_matrix/base_matrix_macros.hpp b/base_matrix/base_matrix_macros.hpp
index b60053f..0f1aa34 100644
--- a/base_matrix/base_matrix_macros.hpp
+++ b/base_matrix/base_matrix_macros.hpp
@@ -1,13 +1,13 @@
-#ifndef BASE_MATRIX_MACROS_HPP
-#define BASE_MATRIX_MACROS_HPP
+#ifndef __BASE_MATRIX_MACROS_HPP__
+#define __BASE_MATRIX_MACROS_HPP__
 
 /* Uncomment if you want to use std::vector */
-// #define BASE_MATRIX_USE_STD_VECTOR
+// #define __BASE_MATRIX_USE_STD_VECTOR__
 
 /* Uncomment if you want to use for loop iteration */
-// #define BASE_MATRIX_USE_FOR_LOOP_OPERATION
+// #define __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
 /* Uncomment if you want to use std::math */
-#define BASE_MATH_USE_STD_MATH
+#define __BASE_MATH_USE_STD_MATH__
 
-#endif // BASE_MATRIX_MACROS_HPP
+#endif // __BASE_MATRIX_MACROS_HPP__
diff --git a/base_matrix/base_matrix_matrix.hpp b/base_matrix/base_matrix_matrix.hpp
index 1624779..8e356d2 100644
--- a/base_matrix/base_matrix_matrix.hpp
+++ b/base_matrix/base_matrix_matrix.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_MATRIX_HPP
-#define BASE_MATRIX_MATRIX_HPP
+#ifndef __BASE_MATRIX_MATRIX_HPP__
+#define __BASE_MATRIX_MATRIX_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -19,7 +19,7 @@ namespace Matrix {
 
 template <typename T, std::size_t M, std::size_t N> class Matrix {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   Matrix() : data(N, std::vector<T>(M, static_cast<T>(0))) {}
 
@@ -52,7 +52,7 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
     }
   }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   Matrix() : data{} {}
 
@@ -90,7 +90,7 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
     }
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   Matrix(const Matrix<T, M, N> &other) : data(other.data) {}
@@ -138,17 +138,17 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
   static inline Matrix<T, M, M> identity() {
     Matrix<T, M, M> identity;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     for (std::size_t i = 0; i < M; i++) {
       identity(i, i) = static_cast<T>(1);
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     COMPILED_MATRIX_IDENTITY<T, M>(identity);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     return identity;
   }
@@ -197,7 +197,7 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
   static inline Matrix<T, M, N> ones() {
     Matrix<T, M, N> Ones;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     for (std::size_t i = 0; i < M; i++) {
       for (std::size_t j = 0; j < N; j++) {
@@ -205,11 +205,11 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
       }
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     COMPILED_MATRIX_ONES<T, M, N>(Ones);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     return Ones;
   }
@@ -248,7 +248,7 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
     return this->data[row][col];
   }
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   std::vector<T> &operator()(std::size_t row) {
     if (row >= N) {
@@ -266,7 +266,7 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
     return this->data[row];
   }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   std::array<T, M> &operator()(std::size_t row) {
     if (row >= N) {
@@ -284,7 +284,7 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
     return this->data[row];
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   constexpr std::size_t rows() const { return N; }
 
@@ -321,11 +321,11 @@ template <typename T, std::size_t M, std::size_t N> class Matrix {
   inline T get_trace() const { return output_matrix_trace(*this); }
 
 /* Variable */
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<std::vector<T>> data;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<std::array<T, M>, N> data;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 };
 
 /* swap columns */
@@ -371,7 +371,7 @@ inline void matrix_col_swap(std::size_t col_1, std::size_t col_2,
     col_2 = M - 1;
   }
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; i++) {
     temp = mat(col_1, i);
@@ -379,11 +379,11 @@ inline void matrix_col_swap(std::size_t col_1, std::size_t col_2,
     mat(col_2, i) = temp;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_COLUMN_SWAP<T, M, N>(col_1, col_2, mat, temp);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 /* swap rows */
@@ -427,17 +427,17 @@ inline T output_matrix_trace(const Matrix<T, M, N> &mat) {
   static_assert(M == N, "Matrix must be square matrix");
   T trace = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; i++) {
     trace += mat(i, i);
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   trace = Base::Matrix::COMPILED_MATRIX_TRACE<T, M, N>(mat);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return trace;
 }
@@ -494,7 +494,7 @@ inline Matrix<T, M, N> operator+(const Matrix<T, M, N> &A,
                                  const Matrix<T, M, N> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -502,11 +502,11 @@ inline Matrix<T, M, N> operator+(const Matrix<T, M, N> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_ADD_MATRIX<T, M, N>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -563,7 +563,7 @@ inline Matrix<T, M, N> operator-(const Matrix<T, M, N> &A,
                                  const Matrix<T, M, N> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -571,11 +571,11 @@ inline Matrix<T, M, N> operator-(const Matrix<T, M, N> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_SUB_MATRIX<T, M, N>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -625,7 +625,7 @@ template <typename T, std::size_t M, std::size_t N>
 inline Matrix<T, M, N> operator-(const Matrix<T, M, N> &A) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -633,11 +633,11 @@ inline Matrix<T, M, N> operator-(const Matrix<T, M, N> &A) {
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_MINUS_MATRIX<T, M, N>(A, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -695,7 +695,7 @@ template <typename T, std::size_t M, std::size_t N>
 inline Matrix<T, M, N> operator*(const T &scalar, const Matrix<T, M, N> &mat) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = 0; k < N; ++k) {
@@ -703,11 +703,11 @@ inline Matrix<T, M, N> operator*(const T &scalar, const Matrix<T, M, N> &mat) {
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SCALAR_MULTIPLY_MATRIX<T, M, N>(scalar, mat, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -716,7 +716,7 @@ template <typename T, std::size_t M, std::size_t N>
 inline Matrix<T, M, N> operator*(const Matrix<T, M, N> &mat, const T &scalar) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < M; ++j) {
     for (std::size_t k = 0; k < N; ++k) {
@@ -724,11 +724,11 @@ inline Matrix<T, M, N> operator*(const Matrix<T, M, N> &mat, const T &scalar) {
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SCALAR_MULTIPLY_MATRIX<T, M, N>(scalar, mat, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -785,7 +785,7 @@ inline Vector<T, M> operator*(const Matrix<T, M, N> &mat,
                               const Vector<T, N> &vec) {
   Vector<T, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     T sum = 0;
@@ -795,11 +795,11 @@ inline Vector<T, M> operator*(const Matrix<T, M, N> &mat,
     result[i] = sum;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::BASE_MATRIX_MATRIX_MULTIPLY_VECTOR<T, M, N>(mat, vec, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -856,7 +856,7 @@ inline Matrix<T, L, N> operator*(const Vector<T, L> &vec,
   static_assert(M == 1, "Invalid size.");
   Matrix<T, L, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < N; ++j) {
     for (std::size_t k = 0; k < L; ++k) {
@@ -864,11 +864,11 @@ inline Matrix<T, L, N> operator*(const Vector<T, L> &vec,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_MULTIPLY_MATRIX<T, L, M, N>(vec, mat, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -926,7 +926,7 @@ inline ColVector<T, N> operator*(const ColVector<T, M> &vec,
                                  const Matrix<T, M, N> &mat) {
   ColVector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t j = 0; j < N; ++j) {
     T sum = 0;
@@ -936,12 +936,12 @@ inline ColVector<T, N> operator*(const ColVector<T, M> &vec,
     result[j] = sum;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_COLUMN_VECTOR_MULTIPLY_MATRIX<T, M, N>(vec, mat,
                                                                 result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1019,7 +1019,7 @@ inline Matrix<T, M, N> operator*(const Matrix<T, M, K> &A,
                                  const Matrix<T, K, N> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1031,11 +1031,11 @@ inline Matrix<T, M, N> operator*(const Matrix<T, M, K> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_MULTIPLY<T, M, K, N>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1086,7 +1086,7 @@ template <typename T, std::size_t M, std::size_t N>
 inline Matrix<T, N, M> output_matrix_transpose(const Matrix<T, M, N> &mat) {
   Matrix<T, N, M> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1094,11 +1094,11 @@ inline Matrix<T, N, M> output_matrix_transpose(const Matrix<T, M, N> &mat) {
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_TRANSPOSE<T, M, N>(mat, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1199,7 +1199,7 @@ matrix_multiply_Upper_triangular_A_mul_B(const Matrix<T, M, K> &A,
                                          const Matrix<T, K, N> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1211,12 +1211,12 @@ matrix_multiply_Upper_triangular_A_mul_B(const Matrix<T, M, K> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_UPPER_TRIANGULAR_MATRIX_MULTIPLY<T, M, K, N>(A, B,
                                                                       result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1302,7 +1302,7 @@ inline Matrix<T, M, N> matrix_multiply_AT_mul_B(const Matrix<T, K, M> &A,
                                                 const Matrix<T, K, N> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1314,11 +1314,11 @@ inline Matrix<T, M, N> matrix_multiply_AT_mul_B(const Matrix<T, K, M> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_T_MULTIPLY_MATRIX<T, M, K, N>(A, B, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1379,7 +1379,7 @@ inline Vector<T, N> matrix_multiply_AT_mul_b(const Matrix<T, M, N> &A,
                                              const Vector<T, M> &b) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t n = 0; n < N; ++n) {
     T sum = 0;
@@ -1389,12 +1389,12 @@ inline Vector<T, N> matrix_multiply_AT_mul_b(const Matrix<T, M, N> &A,
     result[n] = sum;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::BASE_MATRIX_MATRIX_TRANSPOSE_MULTIPLY_VECTOR<T, M, N>(A, b,
                                                                       result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1482,7 +1482,7 @@ matrix_multiply_A_mul_BTranspose(const Matrix<T, M, K> &A,
                                  const Matrix<T, N, K> &B) {
   Matrix<T, M, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1494,12 +1494,12 @@ matrix_multiply_A_mul_BTranspose(const Matrix<T, M, K> &A,
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_MULTIPLY_TRANSPOSE_MATRIX<T, M, K, N>(A, B,
                                                                       result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -1560,7 +1560,7 @@ convert_matrix_real_to_complex(const Matrix<T, M, N> &From_matrix) {
 
   Matrix<Complex<T>, M, N> To_matrix;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1568,12 +1568,12 @@ convert_matrix_real_to_complex(const Matrix<T, M, N> &From_matrix) {
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_REAL_TO_COMPLEX<T, M, N>(From_matrix,
                                                          To_matrix);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_matrix;
 }
@@ -1635,7 +1635,7 @@ inline Matrix<T, M, N> get_real_matrix_from_complex_matrix(
 
   Matrix<T, M, N> To_matrix;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1643,12 +1643,12 @@ inline Matrix<T, M, N> get_real_matrix_from_complex_matrix(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_REAL_FROM_COMPLEX<T, M, N>(From_matrix,
                                                            To_matrix);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_matrix;
 }
@@ -1710,7 +1710,7 @@ inline Matrix<T, M, N> get_imag_matrix_from_complex_matrix(
 
   Matrix<T, M, N> To_matrix;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < M; ++i) {
     for (std::size_t j = 0; j < N; ++j) {
@@ -1718,12 +1718,12 @@ inline Matrix<T, M, N> get_imag_matrix_from_complex_matrix(
     }
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_MATRIX_IMAG_FROM_COMPLEX<T, M, N>(From_matrix,
                                                            To_matrix);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_matrix;
 }
@@ -1731,4 +1731,4 @@ inline Matrix<T, M, N> get_imag_matrix_from_complex_matrix(
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_MATRIX_HPP
+#endif // __BASE_MATRIX_MATRIX_HPP__
diff --git a/base_matrix/base_matrix_qr_decomposition.hpp b/base_matrix/base_matrix_qr_decomposition.hpp
index e120cf9..04486c5 100644
--- a/base_matrix/base_matrix_qr_decomposition.hpp
+++ b/base_matrix/base_matrix_qr_decomposition.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_QR_DECOMPOSITION_HPP
-#define BASE_MATRIX_QR_DECOMPOSITION_HPP
+#ifndef __BASE_MATRIX_QR_DECOMPOSITION_HPP__
+#define __BASE_MATRIX_QR_DECOMPOSITION_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -198,4 +198,4 @@ class QRDecompositionSparse {
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_QR_DECOMPOSITION_HPP
+#endif // __BASE_MATRIX_QR_DECOMPOSITION_HPP__
diff --git a/base_matrix/base_matrix_sparse.hpp b/base_matrix/base_matrix_sparse.hpp
index 38d9de2..f44688c 100644
--- a/base_matrix/base_matrix_sparse.hpp
+++ b/base_matrix/base_matrix_sparse.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_SPARSE_HPP
-#define BASE_MATRIX_SPARSE_HPP
+#ifndef __BASE_MATRIX_SPARSE_HPP__
+#define __BASE_MATRIX_SPARSE_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -22,7 +22,7 @@ const double SPARSE_MATRIX_JUDGE_ZERO_LIMIT_VALUE = 1.0e-20;
 template <typename T, std::size_t M, std::size_t N, std::size_t V>
 class SparseMatrix {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   SparseMatrix()
       : values(V, static_cast<T>(0)),
@@ -68,7 +68,7 @@ class SparseMatrix {
     }
   }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   SparseMatrix() : values{}, row_indices{}, row_pointers{} {}
 
@@ -130,7 +130,7 @@ class SparseMatrix {
     }
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   SparseMatrix(const SparseMatrix<T, M, N, V> &other)
@@ -298,30 +298,30 @@ class SparseMatrix {
   constexpr std::size_t cols() const { return M; }
 
 /* Variable */
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> values;
   std::vector<std::size_t> row_indices;
   std::vector<std::size_t> row_pointers;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, V> values;
   std::array<std::size_t, V> row_indices;
   std::array<std::size_t, M + 1> row_pointers;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 };
 
 template <typename T, std::size_t M, std::size_t N>
 inline SparseMatrix<T, M, N, (M * N)> create_sparse(const Matrix<T, M, N> &A) {
   std::size_t consecutive_index = 0;
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> values(M * N);
   std::vector<std::size_t> row_indices(M * N);
   std::vector<std::size_t> row_pointers(M + 1);
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, (M * N)> values;
   std::array<std::size_t, (M * N)> row_indices;
   std::array<std::size_t, (M + 1)> row_pointers;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   row_pointers[0] = 0;
   for (std::size_t i = 0; i < M; i++) {
@@ -342,15 +342,15 @@ template <typename T, std::size_t M>
 inline SparseMatrix<T, M, M, M> create_sparse(const DiagMatrix<T, M> &A) {
   std::size_t consecutive_index = 0;
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> values(M);
   std::vector<std::size_t> row_indices(M);
   std::vector<std::size_t> row_pointers(M + 1);
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, M> values;
   std::array<std::size_t, M> row_indices;
   std::array<std::size_t, M + 1> row_pointers;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   row_pointers[0] = 0;
   for (std::size_t i = 0; i < M; i++) {
@@ -699,4 +699,4 @@ matrix_multiply_SparseAT_mul_B(const SparseMatrix<T, N, M, V> &A,
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_SPARSE_HPP
+#endif // __BASE_MATRIX_SPARSE_HPP__
diff --git a/base_matrix/base_matrix_templates.hpp b/base_matrix/base_matrix_templates.hpp
index f68a998..032e187 100644
--- a/base_matrix/base_matrix_templates.hpp
+++ b/base_matrix/base_matrix_templates.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_TEMPLATES_HPP
-#define BASE_MATRIX_TEMPLATES_HPP
+#ifndef __BASE_MATRIX_TEMPLATES_HPP__
+#define __BASE_MATRIX_TEMPLATES_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -965,4 +965,4 @@ using SparseAvailableMatrixMultiply =
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_TEMPLATES_HPP
+#endif // __BASE_MATRIX_TEMPLATES_HPP__
diff --git a/base_matrix/base_matrix_triangular_sparse.hpp b/base_matrix/base_matrix_triangular_sparse.hpp
index 2d56109..6ea8f76 100644
--- a/base_matrix/base_matrix_triangular_sparse.hpp
+++ b/base_matrix/base_matrix_triangular_sparse.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_TRIANGULAR_SPARSE_HPP
-#define BASE_MATRIX_TRIANGULAR_SPARSE_HPP
+#ifndef __BASE_MATRIX_TRIANGULAR_SPARSE_HPP__
+#define __BASE_MATRIX_TRIANGULAR_SPARSE_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -183,7 +183,7 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
                          UpperTriangularRowPointers<M, N>>
         Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     std::size_t consecutive_index = 0;
 
@@ -195,11 +195,11 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
       }
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     Base::Matrix::SET_UPPER_TRIANGULAR_VALUES<T, M, N>(Y, A);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     return Y;
   }
@@ -211,7 +211,7 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
     // Currently, only support M >= N.
     static_assert(M >= N, "M must be greater than or equal to N");
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     std::size_t consecutive_index = 0;
 
@@ -222,11 +222,11 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
       }
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     Base::Matrix::SET_UPPER_TRIANGULAR_VALUES<T, M, N>(A, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
   }
 
   /* Lower */
@@ -253,7 +253,7 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
                          LowerTriangularRowPointers<M, N>>
         Y;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     std::size_t consecutive_index = 0;
 
@@ -265,11 +265,11 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
       }
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     Base::Matrix::SET_LOWER_TRIANGULAR_VALUES<T, M, N>(Y, A);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     return Y;
   }
@@ -281,7 +281,7 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
     // Currently, only support M <= N.
     static_assert(M <= N, "M must be smaller than or equal to N");
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     std::size_t consecutive_index = 0;
 
@@ -292,15 +292,15 @@ template <typename T, std::size_t M, std::size_t N> class TriangularSparse {
       }
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     Base::Matrix::SET_LOWER_TRIANGULAR_VALUES<T, M, N>(A, B);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
   }
 };
 
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_TRIANGULAR_SPARSE_HPP
+#endif // __BASE_MATRIX_TRIANGULAR_SPARSE_HPP__
diff --git a/base_matrix/base_matrix_variable_sparse.hpp b/base_matrix/base_matrix_variable_sparse.hpp
index 77c4d0a..3c97170 100644
--- a/base_matrix/base_matrix_variable_sparse.hpp
+++ b/base_matrix/base_matrix_variable_sparse.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_VARIABLE_SPARSE_HPP
-#define BASE_MATRIX_VARIABLE_SPARSE_HPP
+#ifndef __BASE_MATRIX_VARIABLE_SPARSE_HPP__
+#define __BASE_MATRIX_VARIABLE_SPARSE_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -17,14 +17,14 @@ namespace Matrix {
 
 template <typename T, std::size_t M, std::size_t N> class VariableSparseMatrix {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   VariableSparseMatrix()
       : values(M * N, static_cast<T>(0)),
         row_indices(M * N, static_cast<std::size_t>(0)),
         row_pointers(M + 1, static_cast<std::size_t>(0)) {}
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   VariableSparseMatrix() : values{}, row_indices{}, row_pointers{} {}
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   VariableSparseMatrix(const VariableSparseMatrix<T, M, N> &matrix)
@@ -75,15 +75,15 @@ template <typename T, std::size_t M, std::size_t N> class VariableSparseMatrix {
   }
 
 /* Variable */
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> values;
   std::vector<std::size_t> row_indices;
   std::vector<std::size_t> row_pointers;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, M * N> values;
   std::array<std::size_t, M * N> row_indices;
   std::array<std::size_t, M + 1> row_pointers;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 };
 
 /* SparseMatrix * Matrix */
@@ -196,4 +196,4 @@ inline Matrix<T, M, K> operator*(const VariableSparseMatrix<T, M, N> &A,
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_VARIABLE_SPARSE_HPP
+#endif // __BASE_MATRIX_VARIABLE_SPARSE_HPP__
diff --git a/base_matrix/base_matrix_vector.hpp b/base_matrix/base_matrix_vector.hpp
index 3e8efee..e5ce2d6 100644
--- a/base_matrix/base_matrix_vector.hpp
+++ b/base_matrix/base_matrix_vector.hpp
@@ -1,5 +1,5 @@
-#ifndef BASE_MATRIX_VECTOR_HPP
-#define BASE_MATRIX_VECTOR_HPP
+#ifndef __BASE_MATRIX_VECTOR_HPP__
+#define __BASE_MATRIX_VECTOR_HPP__
 
 #include "base_matrix_macros.hpp"
 
@@ -20,7 +20,7 @@ namespace Matrix {
 /* Vector */
 template <typename T, std::size_t N> class Vector {
 public:
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
   Vector() : data(N, static_cast<T>(0)) {}
 
@@ -28,7 +28,7 @@ template <typename T, std::size_t N> class Vector {
 
   Vector(const std::vector<T> &input) : data(input) {}
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
   Vector() : data{} {}
 
@@ -46,7 +46,7 @@ template <typename T, std::size_t N> class Vector {
     std::copy(input.begin(), input.end(), this->data.begin());
   }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
   /* Copy Constructor */
   Vector(const Vector<T, N> &vector) : data(vector.data) {}
@@ -112,17 +112,17 @@ template <typename T, std::size_t N> class Vector {
   inline T dot(const Vector<T, N> &other) const {
     T result = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     for (std::size_t i = 0; i < N; ++i) {
       result += this->data[i] * other[i];
     }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     result = VECTOR_DOT<T, N>(*this, other);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
     return result;
   }
@@ -156,11 +156,11 @@ template <typename T, std::size_t N> class Vector {
   }
 
 /* Variable */
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
   std::vector<T> data;
-#else  // BASE_MATRIX_USE_STD_VECTOR
+#else  // __BASE_MATRIX_USE_STD_VECTOR__
   std::array<T, N> data;
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 };
 
 template <typename T, std::size_t N> class ColVector : public Vector<T, N> {
@@ -201,34 +201,34 @@ template <typename T, std::size_t N>
 inline void vector_normalize(Vector<T, N> &vec) {
   T norm_inv = vec.norm_inv();
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     vec[i] *= norm_inv;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_NORMALIZE<T, N>(vec, norm_inv);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t N>
 inline void vector_normalize(Vector<T, N> &vec, const T &division_min) {
   T norm_inv = vec.norm_inv(division_min);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     vec[i] *= norm_inv;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_NORMALIZE<T, N>(vec, norm_inv);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 /* Scalar Addition */
@@ -258,17 +258,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator+(const Vector<T, N> &vec, const T &scalar) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = vec.data[i] + scalar;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_ADD_SCALAR<T, N>(vec, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -277,17 +277,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator+(const T &scalar, const Vector<T, N> &vec) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = scalar + vec[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_ADD_SCALAR<T, N>(vec, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -320,17 +320,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator-(const Vector<T, N> &vec, const T &scalar) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = vec[i] - scalar;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_SUB_SCALAR<T, N>(vec, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -362,17 +362,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator-(const T &scalar, const Vector<T, N> &vec) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = scalar - vec[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_SCALAR_SUB_VECTOR<T, N>(scalar, vec, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -407,17 +407,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator+(const Vector<T, N> &a, const Vector<T, N> &b) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = a[i] + b[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_ADD_VECTOR<T, N>(a, b, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -452,17 +452,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator-(const Vector<T, N> &a, const Vector<T, N> &b) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = a[i] - b[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_SUB_VECTOR<T, N>(a, b, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -495,17 +495,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator*(const Vector<T, N> &vec, const T &scalar) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = vec[i] * scalar;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_MULTIPLY_SCALAR<T, N>(vec, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -514,17 +514,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator*(const T &scalar, const Vector<T, N> &vec) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = scalar * vec[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_VECTOR_MULTIPLY_SCALAR<T, N>(vec, scalar, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -557,17 +557,17 @@ template <typename T, std::size_t N>
 inline Vector<T, N> operator*(const Vector<T, N> &a, const Vector<T, N> &b) {
   Vector<T, N> result;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     result[i] = a[i] * b[i];
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::VECTOR_MULTIPLY<T, N>(a, b, result);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return result;
 }
@@ -601,18 +601,18 @@ template <typename T, std::size_t N>
 inline T complex_vector_norm(const Vector<Complex<T>, N> &vec_comp) {
   T sum = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     sum += vec_comp[i].real * vec_comp[i].real +
            vec_comp[i].imag * vec_comp[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   sum = Base::Matrix::COMPILED_COMPLEX_VECTOR_NORM<T, N>(vec_comp);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Base::Math::sqrt<T, Base::Math::SQRT_REPEAT_NUMBER_MOSTLY_ACCURATE>(
       sum);
@@ -623,18 +623,18 @@ inline T complex_vector_norm(const Vector<Complex<T>, N> &vec_comp,
                              const T &division_min) {
   T sum = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     sum += vec_comp[i].real * vec_comp[i].real +
            vec_comp[i].imag * vec_comp[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   sum = Base::Matrix::COMPILED_COMPLEX_VECTOR_NORM<T, N>(vec_comp);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Base::Math::sqrt<T>(sum, division_min);
 }
@@ -643,18 +643,18 @@ template <typename T, std::size_t N>
 inline T complex_vector_norm_inv(const Vector<Complex<T>, N> &vec_comp) {
   T sum = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     sum += vec_comp[i].real * vec_comp[i].real +
            vec_comp[i].imag * vec_comp[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   sum = Base::Matrix::COMPILED_COMPLEX_VECTOR_NORM<T, N>(vec_comp);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Base::Math::rsqrt<T>(sum);
 }
@@ -664,18 +664,18 @@ inline T complex_vector_norm_inv(const Vector<Complex<T>, N> &vec_comp,
                                  const T &division_min) {
   T sum = static_cast<T>(0);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     sum += vec_comp[i].real * vec_comp[i].real +
            vec_comp[i].imag * vec_comp[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   sum = Base::Matrix::COMPILED_COMPLEX_VECTOR_NORM<T, N>(vec_comp);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return Base::Math::rsqrt<T>(sum, division_min);
 }
@@ -707,17 +707,17 @@ template <typename T, std::size_t N>
 inline void complex_vector_normalize(Vector<Complex<T>, N> &vec) {
   T norm_inv = complex_vector_norm_inv(vec);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     vec[i] *= norm_inv;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_COMPLEX_VECTOR_NORMALIZE<T, N>(vec, norm_inv);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 template <typename T, std::size_t N>
@@ -725,17 +725,17 @@ inline void complex_vector_normalize(Vector<Complex<T>, N> &vec,
                                      const T &division_min) {
   T norm_inv = complex_vector_norm_inv(vec, division_min);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     vec[i] *= norm_inv;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   Base::Matrix::COMPILED_COMPLEX_VECTOR_NORMALIZE<T, N>(vec, norm_inv);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 }
 
 /* Get Real and Imaginary Vector from Complex Vector */
@@ -839,7 +839,7 @@ struct GetImagFromComplexVectorCore<T, N, 0> {
   }
 };
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
 
 template <typename T, std::size_t N>
 inline std::vector<T> get_real_vector_from_complex_vector(
@@ -847,17 +847,17 @@ inline std::vector<T> get_real_vector_from_complex_vector(
 
   std::vector<T> To_vector(N);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     To_vector[i] = From_vector[i].real;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   GetRealFromComplexVectorCore<T, N, N - 1>::compute(To_vector, From_vector);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_vector;
 }
@@ -868,22 +868,22 @@ inline std::vector<T> get_imag_vector_from_complex_vector(
 
   std::vector<T> To_vector(N);
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     To_vector[i] = From_vector[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   GetImagFromComplexVectorCore<T, N, N - 1>::compute(To_vector, From_vector);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_vector;
 }
 
-#else // BASE_MATRIX_USE_STD_VECTOR
+#else // __BASE_MATRIX_USE_STD_VECTOR__
 
 template <typename T, std::size_t N>
 inline std::array<T, N> get_real_vector_from_complex_vector(
@@ -891,17 +891,17 @@ inline std::array<T, N> get_real_vector_from_complex_vector(
 
   std::array<T, N> To_vector;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     To_vector[i] = From_vector[i].real;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   GetRealFromComplexVectorCore<T, N, N - 1>::compute(To_vector, From_vector);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_vector;
 }
@@ -912,22 +912,22 @@ inline std::array<T, N> get_imag_vector_from_complex_vector(
 
   std::array<T, N> To_vector;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     To_vector[i] = From_vector[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   GetImagFromComplexVectorCore<T, N, N - 1>::compute(To_vector, From_vector);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_vector;
 }
 
-#endif // BASE_MATRIX_USE_STD_VECTOR
+#endif // __BASE_MATRIX_USE_STD_VECTOR__
 
 template <typename T, std::size_t N>
 inline Vector<T, N>
@@ -935,17 +935,17 @@ get_real_vector_from_complex_vector(const Vector<Complex<T>, N> &From_vector) {
 
   Vector<T, N> To_vector;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     To_vector[i] = From_vector[i].real;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   GetRealFromComplexVectorCore<T, N, N - 1>::compute(To_vector, From_vector);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_vector;
 }
@@ -956,17 +956,17 @@ get_imag_vector_from_complex_vector(const Vector<Complex<T>, N> &From_vector) {
 
   Vector<T, N> To_vector;
 
-#ifdef BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#ifdef __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   for (std::size_t i = 0; i < N; ++i) {
     To_vector[i] = From_vector[i].imag;
   }
 
-#else // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#else // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   GetImagFromComplexVectorCore<T, N, N - 1>::compute(To_vector, From_vector);
 
-#endif // BASE_MATRIX_USE_FOR_LOOP_OPERATION
+#endif // __BASE_MATRIX_USE_FOR_LOOP_OPERATION__
 
   return To_vector;
 }
@@ -974,4 +974,4 @@ get_imag_vector_from_complex_vector(const Vector<Complex<T>, N> &From_vector) {
 } // namespace Matrix
 } // namespace Base
 
-#endif // BASE_MATRIX_VECTOR_HPP
+#endif // __BASE_MATRIX_VECTOR_HPP__
diff --git a/external_libraries/base_utility_cpp b/external_libraries/base_utility_cpp
index b0349d2..05fdcd2 160000
--- a/external_libraries/base_utility_cpp
+++ b/external_libraries/base_utility_cpp
@@ -1 +1 @@
-Subproject commit b0349d248b67bf9c5d374be5fd9891b365072d96
+Subproject commit 05fdcd2909e406b31938b109b9f23b895739e8df
diff --git a/external_libraries/python_math_to_cpp b/external_libraries/python_math_to_cpp
index 3e228b6..bf48d9f 160000
--- a/external_libraries/python_math_to_cpp
+++ b/external_libraries/python_math_to_cpp
@@ -1 +1 @@
-Subproject commit 3e228b67801dd30721d34143466bd21055abd3f0
+Subproject commit bf48d9fc79a0130f1e20ff146a6ab2666e816370
diff --git a/python_numpy/python_numpy.hpp b/python_numpy/python_numpy.hpp
index 5acdf45..b58f9a8 100644
--- a/python_numpy/python_numpy.hpp
+++ b/python_numpy/python_numpy.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_HPP
-#define PYTHON_NUMPY_HPP
+#ifndef __PYTHON_NUMPY_HPP__
+#define __PYTHON_NUMPY_HPP__
 
 #include "python_numpy_base.hpp"
 #include "python_numpy_complex.hpp"
@@ -12,5 +12,4 @@
 #include "python_numpy_templates.hpp"
 #include "python_numpy_transpose_operation.hpp"
 
-
-#endif // PYTHON_NUMPY_HPP
+#endif // __PYTHON_NUMPY_HPP__
diff --git a/python_numpy/python_numpy_base.hpp b/python_numpy/python_numpy_base.hpp
index 2a240f5..c9dab18 100644
--- a/python_numpy/python_numpy_base.hpp
+++ b/python_numpy/python_numpy_base.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_BASE_HPP
-#define PYTHON_NUMPY_BASE_HPP
+#ifndef __PYTHON_NUMPY_BASE_HPP__
+#define __PYTHON_NUMPY_BASE_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_templates.hpp"
@@ -724,4 +724,4 @@ inline auto operator*(const Matrix<DefSparse, T, M, N, SparseAvailable_A> &A,
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_BASE_HPP
+#endif // __PYTHON_NUMPY_BASE_HPP__
diff --git a/python_numpy/python_numpy_complex.hpp b/python_numpy/python_numpy_complex.hpp
index 5edce7c..cff1fef 100644
--- a/python_numpy/python_numpy_complex.hpp
+++ b/python_numpy/python_numpy_complex.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_COMPLEX_HPP
-#define PYTHON_NUMPY_COMPLEX_HPP
+#ifndef __PYTHON_NUMPY_COMPLEX_HPP__
+#define __PYTHON_NUMPY_COMPLEX_HPP__
 
 #include "base_matrix.hpp"
 
@@ -9,4 +9,4 @@ template <typename T> using Complex = Base::Matrix::Complex<T>;
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_COMPLEX_HPP
+#endif // __PYTHON_NUMPY_COMPLEX_HPP__
diff --git a/python_numpy/python_numpy_concatenate.hpp b/python_numpy/python_numpy_concatenate.hpp
index 1e00dd7..d8d5e89 100644
--- a/python_numpy/python_numpy_concatenate.hpp
+++ b/python_numpy/python_numpy_concatenate.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_CONCATENATE_HPP
-#define PYTHON_NUMPY_CONCATENATE_HPP
+#ifndef __PYTHON_NUMPY_CONCATENATE_HPP__
+#define __PYTHON_NUMPY_CONCATENATE_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_base.hpp"
@@ -723,4 +723,4 @@ concatenate_horizontally(const Matrix<DefSparse, T, M, N, SparseAvailable_A> &A,
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_CONCATENATE_HPP
+#endif // __PYTHON_NUMPY_CONCATENATE_HPP__
diff --git a/python_numpy/python_numpy_linalg_cholesky.hpp b/python_numpy/python_numpy_linalg_cholesky.hpp
index 92daf86..6f33db5 100644
--- a/python_numpy/python_numpy_linalg_cholesky.hpp
+++ b/python_numpy/python_numpy_linalg_cholesky.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_LINALG_CHOLESKY_HPP
-#define PYTHON_NUMPY_LINALG_CHOLESKY_HPP
+#ifndef __PYTHON_NUMPY_LINALG_CHOLESKY_HPP__
+#define __PYTHON_NUMPY_LINALG_CHOLESKY_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_base.hpp"
@@ -142,4 +142,4 @@ make_LinalgSolverCholesky(const Matrix<DefSparse, T, M, M, SparseAvailable> &A)
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_LINALG_CHOLESKY_HPP
+#endif // __PYTHON_NUMPY_LINALG_CHOLESKY_HPP__
diff --git a/python_numpy/python_numpy_linalg_eig.hpp b/python_numpy/python_numpy_linalg_eig.hpp
index 6f7a84b..653df1c 100644
--- a/python_numpy/python_numpy_linalg_eig.hpp
+++ b/python_numpy/python_numpy_linalg_eig.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_LINALG_EIG_HPP
-#define PYTHON_NUMPY_LINALG_EIG_HPP
+#ifndef __PYTHON_NUMPY_LINALG_EIG_HPP__
+#define __PYTHON_NUMPY_LINALG_EIG_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_base.hpp"
@@ -491,4 +491,4 @@ make_LinalgSolverEig(const Matrix<DefSparse, T, M, M, SparseAvailable> &A)
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_LINALG_EIG_HPP
+#endif // __PYTHON_NUMPY_LINALG_EIG_HPP__
diff --git a/python_numpy/python_numpy_linalg_lu.hpp b/python_numpy/python_numpy_linalg_lu.hpp
index a4578dc..b9f2ca1 100644
--- a/python_numpy/python_numpy_linalg_lu.hpp
+++ b/python_numpy/python_numpy_linalg_lu.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_LINALG_LU_HPP
-#define PYTHON_NUMPY_LINALG_LU_HPP
+#ifndef __PYTHON_NUMPY_LINALG_LU_HPP__
+#define __PYTHON_NUMPY_LINALG_LU_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_base.hpp"
@@ -137,4 +137,4 @@ make_LinalgSolverLU(const Matrix<DefSparse, T, M, M, SparseAvailable> &A)
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_LINALG_LU_HPP
+#endif // __PYTHON_NUMPY_LINALG_LU_HPP__
diff --git a/python_numpy/python_numpy_linalg_qr.hpp b/python_numpy/python_numpy_linalg_qr.hpp
index d9c3645..0ea9095 100644
--- a/python_numpy/python_numpy_linalg_qr.hpp
+++ b/python_numpy/python_numpy_linalg_qr.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_LINALG_QR_HPP
-#define PYTHON_NUMPY_LINALG_QR_HPP
+#ifndef __PYTHON_NUMPY_LINALG_QR_HPP__
+#define __PYTHON_NUMPY_LINALG_QR_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_base.hpp"
@@ -238,4 +238,4 @@ make_LinalgSolverQR(const Matrix<DefSparse, T, M, N, SparseAvailable> &A)
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_LINALG_QR_HPP
+#endif // __PYTHON_NUMPY_LINALG_QR_HPP__
diff --git a/python_numpy/python_numpy_linalg_solver.hpp b/python_numpy/python_numpy_linalg_solver.hpp
index 3161c6c..4281b99 100644
--- a/python_numpy/python_numpy_linalg_solver.hpp
+++ b/python_numpy/python_numpy_linalg_solver.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_LINALG_SOLVER_HPP
-#define PYTHON_NUMPY_LINALG_SOLVER_HPP
+#ifndef __PYTHON_NUMPY_LINALG_SOLVER_HPP__
+#define __PYTHON_NUMPY_LINALG_SOLVER_HPP__
 
 #include "python_numpy_base.hpp"
 #include "python_numpy_templates.hpp"
@@ -646,4 +646,4 @@ make_LinalgLstsqSolver(const Matrix<DefSparse, T, M, N, SparseAvailable_A> &A,
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_LINALG_SOLVER_HPP
+#endif // __PYTHON_NUMPY_LINALG_SOLVER_HPP__
diff --git a/python_numpy/python_numpy_templates.hpp b/python_numpy/python_numpy_templates.hpp
index 789d25a..1085575 100644
--- a/python_numpy/python_numpy_templates.hpp
+++ b/python_numpy/python_numpy_templates.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_TEMPLATES_HPP
-#define PYTHON_NUMPY_TEMPLATES_HPP
+#ifndef __PYTHON_NUMPY_TEMPLATES_HPP__
+#define __PYTHON_NUMPY_TEMPLATES_HPP__
 
 #include "base_matrix.hpp"
 
@@ -81,4 +81,4 @@ using SparseAvailableMatrixMultiply =
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_TEMPLATES_HPP
+#endif // __PYTHON_NUMPY_TEMPLATES_HPP__
diff --git a/python_numpy/python_numpy_transpose_operation.hpp b/python_numpy/python_numpy_transpose_operation.hpp
index 410156c..93a5a9d 100644
--- a/python_numpy/python_numpy_transpose_operation.hpp
+++ b/python_numpy/python_numpy_transpose_operation.hpp
@@ -1,5 +1,5 @@
-#ifndef PYTHON_NUMPY_TRANSPOSE_OPERATION_HPP
-#define PYTHON_NUMPY_TRANSPOSE_OPERATION_HPP
+#ifndef __PYTHON_NUMPY_TRANSPOSE_OPERATION_HPP__
+#define __PYTHON_NUMPY_TRANSPOSE_OPERATION_HPP__
 
 #include "base_matrix.hpp"
 #include "python_numpy_base.hpp"
@@ -186,4 +186,4 @@ ATranspose_mul_B(const Matrix<DefSparse, T, N, M, SparseAvailable_A> &A,
 
 } // namespace PythonNumpy
 
-#endif // PYTHON_NUMPY_TRANSPOSE_OPERATION_HPP
+#endif // __PYTHON_NUMPY_TRANSPOSE_OPERATION_HPP__
diff --git a/test_vs/test_vs_main.cpp b/test_vs/test_vs_main.cpp
index 4c46c13..2192bba 100644
--- a/test_vs/test_vs_main.cpp
+++ b/test_vs/test_vs_main.cpp
@@ -1723,7 +1723,7 @@ void check_eigen_values_and_vectors(void) {
     Matrix<T, 4, 4> Ae({ {11, 8, 5, 10}, {14, 1, 4, 15}, {2, 13, 16, 3}, {7, 12, 9, 6} });
 
     EigenSolverReal<T, 3> eigen_solver(A0, 5, static_cast<T>(1.0e-20F));
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<T> eigen_values = eigen_solver.get_eigen_values();
 #else
     std::array<T, 3> eigen_values = eigen_solver.get_eigen_values();
@@ -1735,7 +1735,7 @@ void check_eigen_values_and_vectors(void) {
     //}
     //std::cout << std::endl << std::endl;
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<T> eigen_values_answer(
 #else
     std::array<T, 3> eigen_values_answer(
@@ -1785,7 +1785,7 @@ void check_eigen_values_and_vectors(void) {
     /* 複素数 固有値 */
     Matrix<Complex<T>, 3, 3> A1_comp({ {1, 2, 3}, {3, 1, 2}, {2, 3, 1} });
     EigenSolverComplex<T, 3> eigen_solver_comp(A1, 5, static_cast<T>(1.0e-20F));
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<Complex<T>> eigen_values_comp
 #else
     std::array<Complex<T>, 3> eigen_values_comp
@@ -1798,13 +1798,13 @@ void check_eigen_values_and_vectors(void) {
     //}
     //std::cout << std::endl << std::endl;
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<T> eigen_values_comp_answer_real(
 #else
     std::array<T, 3> eigen_values_comp_answer_real(
 #endif
         { 6, -1.5F, -1.5F });
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<T> eigen_values_comp_real = get_real_vector_from_complex_vector<T, 3>(eigen_values_comp);
 #else
     std::array<T, 3> eigen_values_comp_real = get_real_vector_from_complex_vector<T, 3>(eigen_values_comp);
@@ -1813,14 +1813,14 @@ void check_eigen_values_and_vectors(void) {
     tester.expect_near(eigen_values_comp_real, eigen_values_comp_answer_real, NEAR_LIMIT_SOFT,
         "check EigenSolverComplex real eigen values.");
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<T> eigen_values_comp_answer_imag(
 #else
     std::array<T, 3> eigen_values_comp_answer_imag(
 #endif
         { 0, 0.8660254F, -0.8660254F });
 
-#ifdef BASE_MATRIX_USE_STD_VECTOR
+#ifdef __BASE_MATRIX_USE_STD_VECTOR__
     std::vector<T> eigen_values_comp_imag = get_imag_vector_from_complex_vector<T, 3>(eigen_values_comp);
 #else
     std::array<T, 3> eigen_values_comp_imag = get_imag_vector_from_complex_vector<T, 3>(eigen_values_comp);